@antv/l7-map 2.21.0 → 2.21.2

package/lib/geo/edge_insets.d.ts

@@ -0,0 +1,54 @@
+import Point from './point';
+/**
+ * An `EdgeInset` object represents screen space padding applied to the edges of the viewport.
+ * This shifts the apprent center or the vanishing point of the map. This is useful for adding floating UI elements
+ * on top of the map and having the vanishing point shift as UI elements resize.
+ *
+ * @param {number} [top=0]
+ * @param {number} [bottom=0]
+ * @param {number} [left=0]
+ * @param {number} [right=0]
+ */
+export default class EdgeInsets {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    constructor(top?: number, bottom?: number, left?: number, right?: number);
+    /**
+     * Interpolates the inset in-place.
+     * This maintains the current inset value for any inset not present in `target`.
+     *
+     * @param {PaddingOptions} target
+     * @param {number} t
+     * @returns {EdgeInsets}
+     * @memberof EdgeInsets
+     */
+    interpolate(start: IPaddingOptions | EdgeInsets, target: IPaddingOptions, t: number): EdgeInsets;
+    /**
+     * Utility method that computes the new apprent center or vanishing point after applying insets.
+     * This is in pixels and with the top left being (0.0) and +y being downwards.
+     *
+     * @param {number} width
+     * @param {number} height
+     * @returns {Point}
+     * @memberof EdgeInsets
+     */
+    getCenter(width: number, height: number): Point;
+    equals(other: IPaddingOptions): boolean;
+    clone(): EdgeInsets;
+    /**
+     * Returns the current sdtate as json, useful when you want to have a
+     * read-only representation of the inset.
+     *
+     * @returns {PaddingOptions}
+     * @memberof EdgeInsets
+     */
+    toJSON(): IPaddingOptions;
+}
+export interface IPaddingOptions {
+    top?: number;
+    bottom?: number;
+    right?: number;
+    left?: number;
+}

package/lib/geo/edge_insets.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _util = require("../util");
 var _point = _interopRequireDefault(require("./point"));
 // @ts-ignore
+
 /**
  * An `EdgeInset` object represents screen space padding applied to the edges of the viewport.
  * This shifts the apprent center or the vanishing point of the map. This is useful for adding floating UI elements
@@ -20,13 +20,12 @@ var _point = _interopRequireDefault(require("./point"));
  * @param {number} [left=0]
  * @param {number} [right=0]
  */
-var EdgeInsets = exports.default = /*#__PURE__*/function () {
-  function EdgeInsets() {
-    var top = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    var bottom = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    var left = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    var right = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-    (0, _classCallCheck2.default)(this, EdgeInsets);
+class EdgeInsets {
+  constructor(top = 0, bottom = 0, left = 0, right = 0) {
+    (0, _defineProperty2.default)(this, "top", void 0);
+    (0, _defineProperty2.default)(this, "bottom", void 0);
+    (0, _defineProperty2.default)(this, "left", void 0);
+    (0, _defineProperty2.default)(this, "right", void 0);
     if (isNaN(top) || top < 0 || isNaN(bottom) || bottom < 0 || isNaN(left) || left < 0 || isNaN(right) || right < 0) {
       throw new Error('Invalid value for edge-insets, top, bottom, left and right must all be numbers');
     }
@@ -45,69 +44,58 @@ var EdgeInsets = exports.default = /*#__PURE__*/function () {
    * @returns {EdgeInsets}
    * @memberof EdgeInsets
    */
-  (0, _createClass2.default)(EdgeInsets, [{
-    key: "interpolate",
-    value: function interpolate(start, target, t) {
-      if (target.top != null && start.top != null) {
-        this.top = (0, _util.interpolate)(start.top, target.top, t);
-      }
-      if (target.bottom != null && start.bottom != null) {
-        this.bottom = (0, _util.interpolate)(start.bottom, target.bottom, t);
-      }
-      if (target.left != null && start.left != null) {
-        this.left = (0, _util.interpolate)(start.left, target.left, t);
-      }
-      if (target.right != null && start.right != null) {
-        this.right = (0, _util.interpolate)(start.right, target.right, t);
-      }
-      return this;
+  interpolate(start, target, t) {
+    if (target.top != null && start.top != null) {
+      this.top = (0, _util.interpolate)(start.top, target.top, t);
     }
-
-    /**
-     * Utility method that computes the new apprent center or vanishing point after applying insets.
-     * This is in pixels and with the top left being (0.0) and +y being downwards.
-     *
-     * @param {number} width
-     * @param {number} height
-     * @returns {Point}
-     * @memberof EdgeInsets
-     */
-  }, {
-    key: "getCenter",
-    value: function getCenter(width, height) {
-      // Clamp insets so they never overflow width/height and always calculate a valid center
-      var x = (0, _util.clamp)((this.left + width - this.right) / 2, 0, width);
-      var y = (0, _util.clamp)((this.top + height - this.bottom) / 2, 0, height);
-      return new _point.default(x, y);
+    if (target.bottom != null && start.bottom != null) {
+      this.bottom = (0, _util.interpolate)(start.bottom, target.bottom, t);
     }
-  }, {
-    key: "equals",
-    value: function equals(other) {
-      return this.top === other.top && this.bottom === other.bottom && this.left === other.left && this.right === other.right;
+    if (target.left != null && start.left != null) {
+      this.left = (0, _util.interpolate)(start.left, target.left, t);
     }
-  }, {
-    key: "clone",
-    value: function clone() {
-      return new EdgeInsets(this.top, this.bottom, this.left, this.right);
+    if (target.right != null && start.right != null) {
+      this.right = (0, _util.interpolate)(start.right, target.right, t);
     }
+    return this;
+  }
 
-    /**
-     * Returns the current sdtate as json, useful when you want to have a
-     * read-only representation of the inset.
-     *
-     * @returns {PaddingOptions}
-     * @memberof EdgeInsets
-     */
-  }, {
-    key: "toJSON",
-    value: function toJSON() {
-      return {
-        top: this.top,
-        bottom: this.bottom,
-        left: this.left,
-        right: this.right
-      };
-    }
-  }]);
-  return EdgeInsets;
-}();
+  /**
+   * Utility method that computes the new apprent center or vanishing point after applying insets.
+   * This is in pixels and with the top left being (0.0) and +y being downwards.
+   *
+   * @param {number} width
+   * @param {number} height
+   * @returns {Point}
+   * @memberof EdgeInsets
+   */
+  getCenter(width, height) {
+    // Clamp insets so they never overflow width/height and always calculate a valid center
+    const x = (0, _util.clamp)((this.left + width - this.right) / 2, 0, width);
+    const y = (0, _util.clamp)((this.top + height - this.bottom) / 2, 0, height);
+    return new _point.default(x, y);
+  }
+  equals(other) {
+    return this.top === other.top && this.bottom === other.bottom && this.left === other.left && this.right === other.right;
+  }
+  clone() {
+    return new EdgeInsets(this.top, this.bottom, this.left, this.right);
+  }
+
+  /**
+   * Returns the current sdtate as json, useful when you want to have a
+   * read-only representation of the inset.
+   *
+   * @returns {PaddingOptions}
+   * @memberof EdgeInsets
+   */
+  toJSON() {
+    return {
+      top: this.top,
+      bottom: this.bottom,
+      left: this.left,
+      right: this.right
+    };
+  }
+}
+exports.default = EdgeInsets;

package/lib/geo/lng_lat.d.ts

@@ -0,0 +1,18 @@
+export declare const earthRadius = 6371008.8;
+export type LngLatLike = LngLat | {
+    lng: number;
+    lat: number;
+} | {
+    lon: number;
+    lat: number;
+} | [number, number];
+export default class LngLat {
+    static convert(input: LngLatLike): LngLat;
+    lng: number;
+    lat: number;
+    constructor(lng: number, lat: number);
+    wrap(): LngLat;
+    toArray(): [number, number];
+    toString(): string;
+    distanceTo(lngLat: LngLat): number;
+}

package/lib/geo/lng_lat.js

@@ -5,16 +5,30 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.earthRadius = exports.default = void 0;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _util = require("../util");
-var earthRadius = exports.earthRadius = 6371008.8;
-var LngLat = exports.default = /*#__PURE__*/function () {
-  function LngLat(lng, lat) {
-    (0, _classCallCheck2.default)(this, LngLat);
+const earthRadius = exports.earthRadius = 6371008.8;
+class LngLat {
+  static convert(input) {
+    if (input instanceof LngLat) {
+      return input;
+    }
+    if (Array.isArray(input) && (input.length === 2 || input.length === 3)) {
+      return new LngLat(Number(input[0]), Number(input[1]));
+    }
+    if (!Array.isArray(input) && typeof input === 'object' && input !== null) {
+      const lng = 'lng' in input ? input.lng : input.lon;
+      return new LngLat(
+      // flow can't refine this to have one of lng or lat, so we have to cast to any
+      Number(lng), Number(input.lat));
+    }
+    throw new Error('`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]');
+  }
+  constructor(lng, lat) {
+    (0, _defineProperty2.default)(this, "lng", void 0);
+    (0, _defineProperty2.default)(this, "lat", void 0);
     if (isNaN(lng) || isNaN(lat)) {
-      throw new Error("Invalid LngLat object: (".concat(lng, ", ").concat(lat, ")"));
+      throw new Error(`Invalid LngLat object: (${lng}, ${lat})`);
     }
     this.lng = +lng;
     this.lat = +lat;
@@ -22,58 +36,32 @@ var LngLat = exports.default = /*#__PURE__*/function () {
       throw new Error('Invalid LngLat latitude value: must be between -90 and 90');
     }
   }
-  (0, _createClass2.default)(LngLat, [{
-    key: "wrap",
-    value: function wrap() {
-      return new LngLat((0, _util.wrap)(this.lng, -180, 180), this.lat);
-    }
-  }, {
-    key: "toArray",
-    value: function toArray() {
-      return [this.lng, this.lat];
-    }
-    // public toBounds(radius: number = 0) {
-    //   const earthCircumferenceInMetersAtEquator = 40075017;
-    //   const latAccuracy = (360 * radius) / earthCircumferenceInMetersAtEquator;
-    //   const lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
+  wrap() {
+    return new LngLat((0, _util.wrap)(this.lng, -180, 180), this.lat);
+  }
+  toArray() {
+    return [this.lng, this.lat];
+  }
+  // public toBounds(radius: number = 0) {
+  //   const earthCircumferenceInMetersAtEquator = 40075017;
+  //   const latAccuracy = (360 * radius) / earthCircumferenceInMetersAtEquator;
+  //   const lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
 
-    //   return new LngLatBounds(
-    //     new LngLat(this.lng - lngAccuracy, this.lat - latAccuracy),
-    //     new LngLat(this.lng + lngAccuracy, this.lat + latAccuracy),
-    //   );
-    // }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "LngLat(".concat(this.lng, ", ").concat(this.lat, ")");
-    }
-  }, {
-    key: "distanceTo",
-    value: function distanceTo(lngLat) {
-      var rad = Math.PI / 180;
-      var lat1 = this.lat * rad;
-      var lat2 = lngLat.lat * rad;
-      var a = Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos((lngLat.lng - this.lng) * rad);
-      var maxMeters = earthRadius * Math.acos(Math.min(a, 1));
-      return maxMeters;
-    }
-  }], [{
-    key: "convert",
-    value: function convert(input) {
-      if (input instanceof LngLat) {
-        return input;
-      }
-      if (Array.isArray(input) && (input.length === 2 || input.length === 3)) {
-        return new LngLat(Number(input[0]), Number(input[1]));
-      }
-      if (!Array.isArray(input) && (0, _typeof2.default)(input) === 'object' && input !== null) {
-        var lng = 'lng' in input ? input.lng : input.lon;
-        return new LngLat(
-        // flow can't refine this to have one of lng or lat, so we have to cast to any
-        Number(lng), Number(input.lat));
-      }
-      throw new Error('`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]');
-    }
-  }]);
-  return LngLat;
-}();
+  //   return new LngLatBounds(
+  //     new LngLat(this.lng - lngAccuracy, this.lat - latAccuracy),
+  //     new LngLat(this.lng + lngAccuracy, this.lat + latAccuracy),
+  //   );
+  // }
+  toString() {
+    return `LngLat(${this.lng}, ${this.lat})`;
+  }
+  distanceTo(lngLat) {
+    const rad = Math.PI / 180;
+    const lat1 = this.lat * rad;
+    const lat2 = lngLat.lat * rad;
+    const a = Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos((lngLat.lng - this.lng) * rad);
+    const maxMeters = earthRadius * Math.acos(Math.min(a, 1));
+    return maxMeters;
+  }
+}
+exports.default = LngLat;

package/lib/geo/lng_lat_bounds.d.ts

@@ -0,0 +1,25 @@
+import type { LngLatLike } from './lng_lat';
+import LngLat from './lng_lat';
+export type LngLatBoundsLike = LngLatBounds | [LngLatLike, LngLatLike] | [number, number, number, number];
+export default class LngLatBounds {
+    static convert(input: LngLatBoundsLike): LngLatBounds;
+    private ne;
+    private sw;
+    constructor(sw?: any, ne?: any);
+    setNorthEast(ne: LngLatLike): this;
+    setSouthWest(sw: LngLatLike): this;
+    extend(obj: LngLatLike | LngLatBoundsLike): this;
+    getCenter(): LngLat;
+    getSouthWest(): LngLat;
+    getNorthEast(): LngLat;
+    getNorthWest(): LngLat;
+    getSouthEast(): LngLat;
+    getWest(): number;
+    getSouth(): number;
+    getEast(): number;
+    getNorth(): number;
+    toArray(): [[number, number], [number, number]];
+    toString(): string;
+    isEmpty(): boolean;
+    contains(lnglat: LngLatLike): boolean;
+}

package/lib/geo/lng_lat_bounds.js

@@ -5,12 +5,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _lng_lat = _interopRequireDefault(require("./lng_lat"));
-var LngLatBounds = exports.default = /*#__PURE__*/function () {
-  function LngLatBounds(sw, ne) {
-    (0, _classCallCheck2.default)(this, LngLatBounds);
+class LngLatBounds {
+  static convert(input) {
+    if (input instanceof LngLatBounds) {
+      return input;
+    }
+    return new LngLatBounds(input);
+  }
+  constructor(sw, ne) {
+    (0, _defineProperty2.default)(this, "ne", void 0);
+    (0, _defineProperty2.default)(this, "sw", void 0);
     if (!sw) {
       // noop
     } else if (ne) {
@@ -21,140 +27,100 @@ var LngLatBounds = exports.default = /*#__PURE__*/function () {
       this.setSouthWest(sw[0]).setNorthEast(sw[1]);
     }
   }
-  (0, _createClass2.default)(LngLatBounds, [{
-    key: "setNorthEast",
-    value: function setNorthEast(ne) {
-      this.ne = ne instanceof _lng_lat.default ? new _lng_lat.default(ne.lng, ne.lat) : _lng_lat.default.convert(ne);
-      return this;
-    }
-  }, {
-    key: "setSouthWest",
-    value: function setSouthWest(sw) {
-      this.sw = sw instanceof _lng_lat.default ? new _lng_lat.default(sw.lng, sw.lat) : _lng_lat.default.convert(sw);
-      return this;
-    }
-  }, {
-    key: "extend",
-    value: function extend(obj) {
-      var sw = this.sw;
-      var ne = this.ne;
-      var sw2;
-      var ne2;
-      if (obj instanceof _lng_lat.default) {
-        sw2 = obj;
-        ne2 = obj;
-      } else if (obj instanceof LngLatBounds) {
-        sw2 = obj.sw;
-        ne2 = obj.ne;
-        if (!sw2 || !ne2) {
-          return this;
-        }
-      } else {
-        if (Array.isArray(obj)) {
-          // @ts-ignore
-          if (obj.length === 4 || obj.every(Array.isArray)) {
-            var lngLatBoundsObj = obj;
-            return this.extend(LngLatBounds.convert(lngLatBoundsObj));
-          } else {
-            var lngLatObj = obj;
-            return this.extend(_lng_lat.default.convert(lngLatObj));
-          }
-        }
+  setNorthEast(ne) {
+    this.ne = ne instanceof _lng_lat.default ? new _lng_lat.default(ne.lng, ne.lat) : _lng_lat.default.convert(ne);
+    return this;
+  }
+  setSouthWest(sw) {
+    this.sw = sw instanceof _lng_lat.default ? new _lng_lat.default(sw.lng, sw.lat) : _lng_lat.default.convert(sw);
+    return this;
+  }
+  extend(obj) {
+    const sw = this.sw;
+    const ne = this.ne;
+    let sw2;
+    let ne2;
+    if (obj instanceof _lng_lat.default) {
+      sw2 = obj;
+      ne2 = obj;
+    } else if (obj instanceof LngLatBounds) {
+      sw2 = obj.sw;
+      ne2 = obj.ne;
+      if (!sw2 || !ne2) {
         return this;
       }
-      if (!sw && !ne) {
-        this.sw = new _lng_lat.default(sw2.lng, sw2.lat);
-        this.ne = new _lng_lat.default(ne2.lng, ne2.lat);
-      } else {
-        sw.lng = Math.min(sw2.lng, sw.lng);
-        sw.lat = Math.min(sw2.lat, sw.lat);
-        ne.lng = Math.max(ne2.lng, ne.lng);
-        ne.lat = Math.max(ne2.lat, ne.lat);
+    } else {
+      if (Array.isArray(obj)) {
+        // @ts-ignore
+        if (obj.length === 4 || obj.every(Array.isArray)) {
+          const lngLatBoundsObj = obj;
+          return this.extend(LngLatBounds.convert(lngLatBoundsObj));
+        } else {
+          const lngLatObj = obj;
+          return this.extend(_lng_lat.default.convert(lngLatObj));
+        }
       }
       return this;
     }
-  }, {
-    key: "getCenter",
-    value: function getCenter() {
-      return new _lng_lat.default((this.sw.lng + this.ne.lng) / 2, (this.sw.lat + this.ne.lat) / 2);
-    }
-  }, {
-    key: "getSouthWest",
-    value: function getSouthWest() {
-      return this.sw;
-    }
-  }, {
-    key: "getNorthEast",
-    value: function getNorthEast() {
-      return this.ne;
-    }
-  }, {
-    key: "getNorthWest",
-    value: function getNorthWest() {
-      return new _lng_lat.default(this.getWest(), this.getNorth());
-    }
-  }, {
-    key: "getSouthEast",
-    value: function getSouthEast() {
-      return new _lng_lat.default(this.getEast(), this.getSouth());
-    }
-  }, {
-    key: "getWest",
-    value: function getWest() {
-      return this.sw.lng;
-    }
-  }, {
-    key: "getSouth",
-    value: function getSouth() {
-      return this.sw.lat;
-    }
-  }, {
-    key: "getEast",
-    value: function getEast() {
-      return this.ne.lng;
-    }
-  }, {
-    key: "getNorth",
-    value: function getNorth() {
-      return this.ne.lat;
-    }
-  }, {
-    key: "toArray",
-    value: function toArray() {
-      return [this.sw.toArray(), this.ne.toArray()];
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "LngLatBounds(".concat(this.sw.toString(), ", ").concat(this.ne.toString(), ")");
-    }
-  }, {
-    key: "isEmpty",
-    value: function isEmpty() {
-      return !(this.sw && this.ne);
-    }
-  }, {
-    key: "contains",
-    value: function contains(lnglat) {
-      var _LngLat$convert = _lng_lat.default.convert(lnglat),
-        lng = _LngLat$convert.lng,
-        lat = _LngLat$convert.lat;
-      var containsLatitude = this.sw.lat <= lat && lat <= this.ne.lat;
-      var containsLongitude = this.sw.lng <= lng && lng <= this.ne.lng;
-      if (this.sw.lng > this.ne.lng) {
-        // wrapped coordinates
-        containsLongitude = this.sw.lng >= lng && lng >= this.ne.lng;
-      }
-      return containsLatitude && containsLongitude;
-    }
-  }], [{
-    key: "convert",
-    value: function convert(input) {
-      if (input instanceof LngLatBounds) {
-        return input;
-      }
-      return new LngLatBounds(input);
+    if (!sw && !ne) {
+      this.sw = new _lng_lat.default(sw2.lng, sw2.lat);
+      this.ne = new _lng_lat.default(ne2.lng, ne2.lat);
+    } else {
+      sw.lng = Math.min(sw2.lng, sw.lng);
+      sw.lat = Math.min(sw2.lat, sw.lat);
+      ne.lng = Math.max(ne2.lng, ne.lng);
+      ne.lat = Math.max(ne2.lat, ne.lat);
     }
-  }]);
-  return LngLatBounds;
-}();
+    return this;
+  }
+  getCenter() {
+    return new _lng_lat.default((this.sw.lng + this.ne.lng) / 2, (this.sw.lat + this.ne.lat) / 2);
+  }
+  getSouthWest() {
+    return this.sw;
+  }
+  getNorthEast() {
+    return this.ne;
+  }
+  getNorthWest() {
+    return new _lng_lat.default(this.getWest(), this.getNorth());
+  }
+  getSouthEast() {
+    return new _lng_lat.default(this.getEast(), this.getSouth());
+  }
+  getWest() {
+    return this.sw.lng;
+  }
+  getSouth() {
+    return this.sw.lat;
+  }
+  getEast() {
+    return this.ne.lng;
+  }
+  getNorth() {
+    return this.ne.lat;
+  }
+  toArray() {
+    return [this.sw.toArray(), this.ne.toArray()];
+  }
+  toString() {
+    return `LngLatBounds(${this.sw.toString()}, ${this.ne.toString()})`;
+  }
+  isEmpty() {
+    return !(this.sw && this.ne);
+  }
+  contains(lnglat) {
+    const {
+      lng,
+      lat
+    } = _lng_lat.default.convert(lnglat);
+    const containsLatitude = this.sw.lat <= lat && lat <= this.ne.lat;
+    let containsLongitude = this.sw.lng <= lng && lng <= this.ne.lng;
+    if (this.sw.lng > this.ne.lng) {
+      // wrapped coordinates
+      containsLongitude = this.sw.lng >= lng && lng >= this.ne.lng;
+    }
+    return containsLatitude && containsLongitude;
+  }
+}
+exports.default = LngLatBounds;

package/lib/geo/mercator.d.ts

@@ -0,0 +1,30 @@
+import type { LngLatLike } from '../geo/lng_lat';
+import LngLat from '../geo/lng_lat';
+export declare function mercatorXfromLng(lng: number): number;
+export declare function mercatorYfromLat(lat: number): number;
+export declare function mercatorZfromAltitude(altitude: number, lat: number): number;
+export declare function lngFromMercatorX(x: number): number;
+export declare function latFromMercatorY(y: number): number;
+export declare function altitudeFromMercatorZ(z: number, y: number): number;
+/**
+ * Determine the Mercator scale factor for a given latitude, see
+ * https://en.wikipedia.org/wiki/Mercator_projection#Scale_factor
+ *
+ * At the equator the scale factor will be 1, which increases at higher latitudes.
+ *
+ * @param {number} lat Latitude
+ * @returns {number} scale factor
+ * @private
+ */
+export declare function mercatorScale(lat: number): number;
+export default class MercatorCoordinate {
+    static fromLngLat(lngLatLike: LngLatLike, altitude?: number): MercatorCoordinate;
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z?: number);
+    toLngLat(): LngLat;
+    toAltitude(): number;
+    meterInMercatorCoordinateUnits(): number;
+}
+export { MercatorCoordinate };