@antv/l7-map 2.9.32-alpha.2 → 2.9.33

package/lib/earthmap.js

@@ -0,0 +1,278 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/earthmap.ts
+var earthmap_exports = {};
+__export(earthmap_exports, {
+  EarthMap: () => EarthMap
+});
+module.exports = __toCommonJS(earthmap_exports);
+var import_l7_utils = require("@antv/l7-utils");
+var import_lodash = require("lodash");
+var import_camera = __toESM(require("./camera"));
+var import_l7 = require("./css/l7.css");
+var import_lng_lat = __toESM(require("./geo/lng_lat"));
+var import_lng_lat_bounds = __toESM(require("./geo/lng_lat_bounds"));
+var import_point = __toESM(require("./geo/point"));
+var import_handler_manager = __toESM(require("./handler/handler_manager"));
+var import_util = require("./util");
+var import_performance = require("./utils/performance");
+var import_task_queue = __toESM(require("./utils/task_queue"));
+var defaultMinZoom = -2;
+var defaultMaxZoom = 22;
+var defaultMinPitch = 0;
+var defaultMaxPitch = 60;
+var DefaultOptions = {
+  hash: false,
+  zoom: -1,
+  center: [112, 32],
+  pitch: 0,
+  bearing: 0,
+  interactive: true,
+  minZoom: defaultMinZoom,
+  maxZoom: defaultMaxZoom,
+  minPitch: defaultMinPitch,
+  maxPitch: defaultMaxPitch,
+  scrollZoom: true,
+  boxZoom: true,
+  dragRotate: true,
+  dragPan: true,
+  keyboard: true,
+  doubleClickZoom: true,
+  touchZoomRotate: true,
+  touchPitch: true,
+  bearingSnap: 7,
+  clickTolerance: 3,
+  pitchWithRotate: true,
+  trackResize: true,
+  renderWorldCopies: true,
+  pitchEnabled: true,
+  rotateEnabled: true
+};
+var EarthMap = class extends import_camera.default {
+  constructor(options) {
+    super((0, import_lodash.merge)({}, DefaultOptions, options));
+    this.renderTaskQueue = new import_task_queue.default();
+    this.trackResize = true;
+    this.onWindowOnline = () => {
+      this.update();
+    };
+    this.onWindowResize = (event) => {
+      if (this.trackResize) {
+        this.resize({ originalEvent: event }).update();
+      }
+    };
+    this.initContainer();
+    this.resize();
+    this.handlers = new import_handler_manager.default(this, this.options);
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", this.onWindowOnline, false);
+      window.addEventListener("resize", this.onWindowResize, false);
+      window.addEventListener("orientationchange", this.onWindowResize, false);
+    }
+  }
+  resize(eventData) {
+    const dimensions = this.containerDimensions();
+    const width = dimensions[0];
+    const height = dimensions[1];
+    this.transform.resize(width, height);
+    const fireMoving = !this.moving;
+    if (fireMoving) {
+      this.stop();
+      this.emit("movestart", new Event("movestart", eventData));
+      this.emit("move", new Event("move", eventData));
+    }
+    this.emit("resize", new Event("resize", eventData));
+    if (fireMoving) {
+      this.emit("moveend", new Event("moveend", eventData));
+    }
+    return this;
+  }
+  getContainer() {
+    return this.container;
+  }
+  getCanvas() {
+    return this.canvas;
+  }
+  getCanvasContainer() {
+    return this.canvasContainer;
+  }
+  project(lngLat) {
+    return this.transform.locationPoint(import_lng_lat.default.convert(lngLat));
+  }
+  unproject(point) {
+    return this.transform.pointLocation(import_point.default.convert(point));
+  }
+  getBounds() {
+    return this.transform.getBounds();
+  }
+  getMaxBounds() {
+    return this.transform.getMaxBounds();
+  }
+  setMaxBounds(bounds) {
+    this.transform.setMaxBounds(import_lng_lat_bounds.default.convert(bounds));
+  }
+  setStyle(style) {
+    return;
+  }
+  setMinZoom(minZoom) {
+    minZoom = minZoom === null || minZoom === void 0 ? defaultMinZoom : minZoom;
+    if (minZoom >= defaultMinZoom && minZoom <= this.transform.maxZoom) {
+      this.transform.minZoom = minZoom;
+      if (this.getZoom() < minZoom) {
+        this.setZoom(minZoom);
+      }
+      return this;
+    } else {
+      throw new Error(`minZoom must be between ${defaultMinZoom} and the current maxZoom, inclusive`);
+    }
+  }
+  getMinZoom() {
+    return this.transform.minZoom;
+  }
+  setMaxZoom(maxZoom) {
+    maxZoom = maxZoom === null || maxZoom === void 0 ? defaultMaxZoom : maxZoom;
+    if (maxZoom >= this.transform.minZoom) {
+      this.transform.maxZoom = maxZoom;
+      if (this.getZoom() > maxZoom) {
+        this.setZoom(maxZoom);
+      }
+      return this;
+    } else {
+      throw new Error("maxZoom must be greater than the current minZoom");
+    }
+  }
+  getMaxZoom() {
+    return this.transform.maxZoom;
+  }
+  setMinPitch(minPitch) {
+    minPitch = minPitch === null || minPitch === void 0 ? defaultMinPitch : minPitch;
+    if (minPitch < defaultMinPitch) {
+      throw new Error(`minPitch must be greater than or equal to ${defaultMinPitch}`);
+    }
+    if (minPitch >= defaultMinPitch && minPitch <= this.transform.maxPitch) {
+      this.transform.minPitch = minPitch;
+      if (this.getPitch() < minPitch) {
+        this.setPitch(minPitch);
+      }
+      return this;
+    } else {
+      throw new Error(`minPitch must be between ${defaultMinPitch} and the current maxPitch, inclusive`);
+    }
+  }
+  getMinPitch() {
+    return this.transform.minPitch;
+  }
+  setMaxPitch(maxPitch) {
+    maxPitch = maxPitch === null || maxPitch === void 0 ? defaultMaxPitch : maxPitch;
+    if (maxPitch > defaultMaxPitch) {
+      throw new Error(`maxPitch must be less than or equal to ${defaultMaxPitch}`);
+    }
+    if (maxPitch >= this.transform.minPitch) {
+      this.transform.maxPitch = maxPitch;
+      if (this.getPitch() > maxPitch) {
+        this.setPitch(maxPitch);
+      }
+      return this;
+    } else {
+      throw new Error("maxPitch must be greater than the current minPitch");
+    }
+  }
+  getMaxPitch() {
+    return this.transform.maxPitch;
+  }
+  getRenderWorldCopies() {
+    return this.transform.renderWorldCopies;
+  }
+  setRenderWorldCopies(renderWorldCopies) {
+    this.transform.renderWorldCopies = !!renderWorldCopies;
+  }
+  remove() {
+    if (this.frame) {
+      this.frame.cancel();
+      this.frame = null;
+    }
+    this.renderTaskQueue.clear();
+  }
+  requestRenderFrame(cb) {
+    this.update();
+    return this.renderTaskQueue.add(cb);
+  }
+  cancelRenderFrame(id) {
+    return this.renderTaskQueue.remove(id);
+  }
+  triggerRepaint() {
+    if (!this.frame) {
+      this.frame = (0, import_util.renderframe)((paintStartTimeStamp) => {
+        import_performance.PerformanceUtils.frame(paintStartTimeStamp);
+        this.frame = null;
+        this.update(paintStartTimeStamp);
+      });
+    }
+  }
+  update(time) {
+    if (!this.frame) {
+      this.frame = (0, import_util.renderframe)((paintStartTimeStamp) => {
+        import_performance.PerformanceUtils.frame(paintStartTimeStamp);
+        this.frame = null;
+        this.renderTaskQueue.run(time);
+      });
+    }
+  }
+  initContainer() {
+    if (typeof this.options.container === "string") {
+      this.container = window.document.getElementById(this.options.container);
+      if (!this.container) {
+        throw new Error(`Container '${this.options.container}' not found.`);
+      }
+    } else if (this.options.container instanceof HTMLElement) {
+      this.container = this.options.container;
+    } else {
+      throw new Error("Invalid type: 'container' must be a String or HTMLElement.");
+    }
+    const container = this.container;
+    container.classList.add("l7-map");
+    const canvasContainer = this.canvasContainer = import_l7_utils.DOM.create("div", "l7-canvas-container", container);
+    if (this.options.interactive) {
+      canvasContainer.classList.add("l7-interactive");
+    }
+  }
+  containerDimensions() {
+    let width = 0;
+    let height = 0;
+    if (this.container) {
+      width = this.container.clientWidth || 400;
+      height = this.container.clientHeight || 300;
+    }
+    return [width, height];
+  }
+  resizeCanvas(width, height) {
+    const pixelRatio = import_l7_utils.DOM.DPR || 1;
+    this.canvas.width = pixelRatio * width;
+    this.canvas.height = pixelRatio * height;
+    this.canvas.style.width = `${width}px`;
+    this.canvas.style.height = `${height}px`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EarthMap
+});

package/lib/geo/edge_insets.js

@@ -0,0 +1,76 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/geo/edge_insets.ts
+var edge_insets_exports = {};
+__export(edge_insets_exports, {
+  default: () => EdgeInsets
+});
+module.exports = __toCommonJS(edge_insets_exports);
+var import_util = require("../util");
+var import_point = __toESM(require("./point"));
+var EdgeInsets = class {
+  constructor(top = 0, bottom = 0, left = 0, right = 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");
+    }
+    this.top = top;
+    this.bottom = bottom;
+    this.left = left;
+    this.right = right;
+  }
+  interpolate(start, target, t) {
+    if (target.top != null && start.top != null) {
+      this.top = (0, import_util.interpolate)(start.top, target.top, t);
+    }
+    if (target.bottom != null && start.bottom != null) {
+      this.bottom = (0, import_util.interpolate)(start.bottom, target.bottom, t);
+    }
+    if (target.left != null && start.left != null) {
+      this.left = (0, import_util.interpolate)(start.left, target.left, t);
+    }
+    if (target.right != null && start.right != null) {
+      this.right = (0, import_util.interpolate)(start.right, target.right, t);
+    }
+    return this;
+  }
+  getCenter(width, height) {
+    const x = (0, import_util.clamp)((this.left + width - this.right) / 2, 0, width);
+    const y = (0, import_util.clamp)((this.top + height - this.bottom) / 2, 0, height);
+    return new import_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);
+  }
+  toJSON() {
+    return {
+      top: this.top,
+      bottom: this.bottom,
+      left: this.left,
+      right: this.right
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/geo/lng_lat.js

@@ -0,0 +1,73 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/geo/lng_lat.ts
+var lng_lat_exports = {};
+__export(lng_lat_exports, {
+  default: () => LngLat,
+  earthRadius: () => earthRadius
+});
+module.exports = __toCommonJS(lng_lat_exports);
+var import_util = require("../util");
+var earthRadius = 63710088e-1;
+var LngLat = class {
+  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(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) {
+    if (isNaN(lng) || isNaN(lat)) {
+      throw new Error(`Invalid LngLat object: (${lng}, ${lat})`);
+    }
+    this.lng = +lng;
+    this.lat = +lat;
+    if (this.lat > 90 || this.lat < -90) {
+      throw new Error("Invalid LngLat latitude value: must be between -90 and 90");
+    }
+  }
+  wrap() {
+    return new LngLat((0, import_util.wrap)(this.lng, -180, 180), this.lat);
+  }
+  toArray() {
+    return [this.lng, this.lat];
+  }
+  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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  earthRadius
+});

package/lib/geo/lng_lat_bounds.js

@@ -0,0 +1,138 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/geo/lng_lat_bounds.ts
+var lng_lat_bounds_exports = {};
+__export(lng_lat_bounds_exports, {
+  default: () => LngLatBounds
+});
+module.exports = __toCommonJS(lng_lat_bounds_exports);
+var import_lng_lat = __toESM(require("./lng_lat"));
+var LngLatBounds = class {
+  static convert(input) {
+    if (input instanceof LngLatBounds) {
+      return input;
+    }
+    return new LngLatBounds(input);
+  }
+  constructor(sw, ne) {
+    if (!sw) {
+    } else if (ne) {
+      this.setSouthWest(sw).setNorthEast(ne);
+    } else if (sw.length === 4) {
+      this.setSouthWest([sw[0], sw[1]]).setNorthEast([sw[2], sw[3]]);
+    } else {
+      this.setSouthWest(sw[0]).setNorthEast(sw[1]);
+    }
+  }
+  setNorthEast(ne) {
+    this.ne = ne instanceof import_lng_lat.default ? new import_lng_lat.default(ne.lng, ne.lat) : import_lng_lat.default.convert(ne);
+    return this;
+  }
+  setSouthWest(sw) {
+    this.sw = sw instanceof import_lng_lat.default ? new import_lng_lat.default(sw.lng, sw.lat) : import_lng_lat.default.convert(sw);
+    return this;
+  }
+  extend(obj) {
+    const sw = this.sw;
+    const ne = this.ne;
+    let sw2;
+    let ne2;
+    if (obj instanceof import_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)) {
+        if (obj.length === 4 || obj.every(Array.isArray)) {
+          const lngLatBoundsObj = obj;
+          return this.extend(LngLatBounds.convert(lngLatBoundsObj));
+        } else {
+          const lngLatObj = obj;
+          return this.extend(import_lng_lat.default.convert(lngLatObj));
+        }
+      }
+      return this;
+    }
+    if (!sw && !ne) {
+      this.sw = new import_lng_lat.default(sw2.lng, sw2.lat);
+      this.ne = new import_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 this;
+  }
+  getCenter() {
+    return new import_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 import_lng_lat.default(this.getWest(), this.getNorth());
+  }
+  getSouthEast() {
+    return new import_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 } = import_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) {
+      containsLongitude = this.sw.lng >= lng && lng >= this.ne.lng;
+    }
+    return containsLatitude && containsLongitude;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/geo/mercator.js

@@ -0,0 +1,91 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/geo/mercator.ts
+var mercator_exports = {};
+__export(mercator_exports, {
+  altitudeFromMercatorZ: () => altitudeFromMercatorZ,
+  default: () => MercatorCoordinate,
+  latFromMercatorY: () => latFromMercatorY,
+  lngFromMercatorX: () => lngFromMercatorX,
+  mercatorScale: () => mercatorScale,
+  mercatorXfromLng: () => mercatorXfromLng,
+  mercatorYfromLat: () => mercatorYfromLat,
+  mercatorZfromAltitude: () => mercatorZfromAltitude
+});
+module.exports = __toCommonJS(mercator_exports);
+var import_lng_lat = __toESM(require("../geo/lng_lat"));
+var earthCircumfrence = 2 * Math.PI * import_lng_lat.earthRadius;
+function circumferenceAtLatitude(latitude) {
+  return earthCircumfrence * Math.cos(latitude * Math.PI / 180);
+}
+function mercatorXfromLng(lng) {
+  return (180 + lng) / 360;
+}
+function mercatorYfromLat(lat) {
+  return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360))) / 360;
+}
+function mercatorZfromAltitude(altitude, lat) {
+  return altitude / circumferenceAtLatitude(lat);
+}
+function lngFromMercatorX(x) {
+  return x * 360 - 180;
+}
+function latFromMercatorY(y) {
+  const y2 = 180 - y * 360;
+  return 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+}
+function altitudeFromMercatorZ(z, y) {
+  return z * circumferenceAtLatitude(latFromMercatorY(y));
+}
+function mercatorScale(lat) {
+  return 1 / Math.cos(lat * Math.PI / 180);
+}
+var MercatorCoordinate = class {
+  static fromLngLat(lngLatLike, altitude = 0) {
+    const lngLat = import_lng_lat.default.convert(lngLatLike);
+    return new MercatorCoordinate(mercatorXfromLng(lngLat.lng), mercatorYfromLat(lngLat.lat), mercatorZfromAltitude(altitude, lngLat.lat));
+  }
+  constructor(x, y, z = 0) {
+    this.x = +x;
+    this.y = +y;
+    this.z = +z;
+  }
+  toLngLat() {
+    return new import_lng_lat.default(lngFromMercatorX(this.x), latFromMercatorY(this.y));
+  }
+  toAltitude() {
+    return altitudeFromMercatorZ(this.z, this.y);
+  }
+  meterInMercatorCoordinateUnits() {
+    return 1 / earthCircumfrence * mercatorScale(latFromMercatorY(this.y));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  altitudeFromMercatorZ,
+  latFromMercatorY,
+  lngFromMercatorX,
+  mercatorScale,
+  mercatorXfromLng,
+  mercatorYfromLat,
+  mercatorZfromAltitude
+});