@antv/l7-map 2.9.32-alpha.4 → 2.9.32-alpha.5

package/lib/camera.js

@@ -1,533 +1,791 @@
-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/camera.ts
-var camera_exports = {};
-__export(camera_exports, {
-  default: () => Camera
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(camera_exports);
-var import_eventemitter3 = require("eventemitter3");
-var import_lodash = require("lodash");
-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_transform = __toESM(require("./geo/transform"));
-var import_event = require("./handler/events/event");
-var import_util = require("./util");
-var Camera = class extends import_eventemitter3.EventEmitter {
-  constructor(options) {
-    super();
-    this.renderFrameCallback = () => {
-      const t = Math.min(((0, import_util.now)() - this.easeStart) / this.easeOptions.duration, 1);
-      this.onEaseFrame(this.easeOptions.easing(t));
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _eventemitter = require("eventemitter3");
+
+var _lodash = require("lodash");
+
+var _lng_lat = _interopRequireDefault(require("./geo/lng_lat"));
+
+var _lng_lat_bounds = _interopRequireDefault(require("./geo/lng_lat_bounds"));
+
+var _point = _interopRequireDefault(require("./geo/point"));
+
+var _transform = _interopRequireDefault(require("./geo/transform"));
+
+var _event = require("./handler/events/event");
+
+var _util = require("./util");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var Camera = /*#__PURE__*/function (_EventEmitter) {
+  (0, _inherits2.default)(Camera, _EventEmitter);
+
+  var _super = _createSuper(Camera);
+
+  // public requestRenderFrame: (_: any) => number;
+  // public cancelRenderFrame: (_: number) => void;
+  function Camera(options) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, Camera);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "renderFrameCallback", function () {
+      var t = Math.min(((0, _util.now)() - _this.easeStart) / _this.easeOptions.duration, 1);
+
+      _this.onEaseFrame(_this.easeOptions.easing(t));
+
       if (t < 1) {
-        this.easeFrameId = this.requestRenderFrame(this.renderFrameCallback);
+        // this.easeFrameId = window.requestAnimationFrame(this.renderFrameCallback);
+        _this.easeFrameId = _this.requestRenderFrame(_this.renderFrameCallback);
       } else {
-        this.stop();
-      }
-    };
-    this.options = options;
-    const { minZoom, maxZoom, minPitch, maxPitch, renderWorldCopies } = options;
-    this.moving = false;
-    this.zooming = false;
-    this.bearingSnap = options.bearingSnap;
-    this.pitchEnabled = options.pitchEnabled;
-    this.rotateEnabled = options.rotateEnabled;
-    this.transform = new import_transform.default(minZoom, maxZoom, minPitch, maxPitch, renderWorldCopies);
-  }
-  requestRenderFrame(cb) {
-    return 0;
-  }
-  cancelRenderFrame(_) {
-    return;
-  }
-  getCenter() {
-    const { lng, lat } = this.transform.center;
-    return new import_lng_lat.default(lng, lat);
-  }
-  getZoom() {
-    return this.transform.zoom;
-  }
-  getPitch() {
-    return this.transform.pitch;
-  }
-  setCenter(center, eventData) {
-    return this.jumpTo({ center }, eventData);
-  }
-  setPitch(pitch, eventData) {
-    this.jumpTo({ pitch }, eventData);
-    return this;
-  }
-  getBearing() {
-    return this.transform.bearing;
-  }
-  panTo(lnglat, options, eventData) {
-    return this.easeTo((0, import_lodash.merge)({
-      center: lnglat
-    }, options), eventData);
-  }
-  zoomOut(options, eventData) {
-    this.zoomTo(this.getZoom() - 1, options, eventData);
-    return this;
-  }
-  setBearing(bearing, eventData) {
-    this.jumpTo({ bearing }, eventData);
-    return this;
-  }
-  setZoom(zoom, eventData) {
-    this.jumpTo({ zoom }, eventData);
-    return this;
-  }
-  zoomIn(options, eventData) {
-    this.zoomTo(this.getZoom() + 1, options, eventData);
-    return this;
-  }
-  zoomTo(zoom, options, eventData) {
-    return this.easeTo((0, import_lodash.merge)({
-      zoom
-    }, options), eventData);
-  }
-  getPadding() {
-    return this.transform.padding;
-  }
-  setPadding(padding, eventData) {
-    this.jumpTo({ padding }, eventData);
-    return this;
-  }
-  rotateTo(bearing, options, eventData) {
-    return this.easeTo((0, import_lodash.merge)({
-      bearing
-    }, options), eventData);
-  }
-  resetNorth(options, eventData) {
-    this.rotateTo(0, (0, import_lodash.merge)({ duration: 1e3 }, options), eventData);
-    return this;
-  }
-  resetNorthPitch(options, eventData) {
-    this.easeTo((0, import_lodash.merge)({
-      bearing: 0,
-      pitch: 0,
-      duration: 1e3
-    }, options), eventData);
-    return this;
-  }
-  fitBounds(bounds, options, eventData) {
-    return this.fitInternal(this.cameraForBounds(bounds, options), options, eventData);
-  }
-  cameraForBounds(bounds, options) {
-    bounds = import_lng_lat_bounds.default.convert(bounds);
-    return this.cameraForBoxAndBearing(bounds.getNorthWest(), bounds.getSouthEast(), 0, options);
+        _this.stop();
+      }
+    });
+    _this.options = options;
+    var minZoom = options.minZoom,
+        maxZoom = options.maxZoom,
+        minPitch = options.minPitch,
+        maxPitch = options.maxPitch,
+        renderWorldCopies = options.renderWorldCopies;
+    _this.moving = false;
+    _this.zooming = false;
+    _this.bearingSnap = options.bearingSnap;
+    _this.pitchEnabled = options.pitchEnabled;
+    _this.rotateEnabled = options.rotateEnabled;
+    _this.transform = new _transform.default(minZoom, maxZoom, minPitch, maxPitch, renderWorldCopies);
+    return _this;
   }
-  snapToNorth(options, eventData) {
-    if (Math.abs(this.getBearing()) < this.bearingSnap) {
-      return this.resetNorth(options, eventData);
+
+  (0, _createClass2.default)(Camera, [{
+    key: "requestRenderFrame",
+    value: function requestRenderFrame(cb) {
+      return 0;
+    }
+  }, {
+    key: "cancelRenderFrame",
+    value: function cancelRenderFrame(_) {
+      return;
     }
-    return this;
-  }
-  jumpTo(options = {}, eventData) {
-    this.stop();
-    const tr = this.transform;
-    let zoomChanged = false;
-    let bearingChanged = false;
-    let pitchChanged = false;
-    if (options.zoom && tr.zoom !== +options.zoom) {
-      zoomChanged = true;
-      tr.zoom = +options.zoom;
-    }
-    if (options.center !== void 0) {
-      tr.center = import_lng_lat.default.convert(options.center);
-    }
-    if (options.bearing && tr.bearing !== +options.bearing) {
-      bearingChanged = true;
-      tr.bearing = +options.bearing;
-    }
-    if (options.pitch && tr.pitch !== +options.pitch) {
-      pitchChanged = true;
-      tr.pitch = +options.pitch;
-    }
-    if (options.padding != null && !tr.isPaddingEqual(options.padding)) {
-      tr.padding = options.padding;
-    }
-    this.emit("movestart", new import_event.Event("movestart", eventData));
-    this.emit("move", new import_event.Event("move", eventData));
-    if (zoomChanged) {
-      this.emit("zoomstart", new import_event.Event("zoomstart", eventData));
-      this.emit("zoom", new import_event.Event("zoom", eventData));
-      this.emit("zoomend", new import_event.Event("zoomend", eventData));
-    }
-    if (bearingChanged) {
-      this.emit("rotatestart", new import_event.Event("rotatestart", eventData));
-      this.emit("rotate", new import_event.Event("rotate", eventData));
-      this.emit("rotateend", new import_event.Event("rotateend", eventData));
-    }
-    if (pitchChanged) {
-      this.emit("pitchstart", new import_event.Event("pitchstart", eventData));
-      this.emit("pitch", new import_event.Event("pitch", eventData));
-      this.emit("pitchend", new import_event.Event("pitchend", eventData));
-    }
-    return this.emit("moveend", new import_event.Event("moveend", eventData));
-  }
-  easeTo(options = {}, eventData) {
-    options = (0, import_lodash.merge)({
-      offset: [0, 0],
-      duration: 500,
-      easing: import_util.ease
-    }, options);
-    if (options.animate === false || !options.essential && (0, import_util.prefersReducedMotion)()) {
-      options.duration = 0;
-    }
-    const tr = this.transform;
-    const startZoom = this.getZoom();
-    const startBearing = this.getBearing();
-    const startPitch = this.getPitch();
-    const startPadding = this.getPadding();
-    const zoom = options.zoom ? +options.zoom : startZoom;
-    const bearing = options.bearing ? this.normalizeBearing(options.bearing, startBearing) : startBearing;
-    const pitch = options.pitch ? +options.pitch : startPitch;
-    const padding = options.padding ? options.padding : tr.padding;
-    const offsetAsPoint = import_point.default.convert(options.offset);
-    let pointAtOffset = tr.centerPoint.add(offsetAsPoint);
-    const locationAtOffset = tr.pointLocation(pointAtOffset);
-    const center = import_lng_lat.default.convert(options.center || locationAtOffset);
-    this.normalizeCenter(center);
-    const from = tr.project(locationAtOffset);
-    const delta = tr.project(center).sub(from);
-    const finalScale = tr.zoomScale(zoom - startZoom);
-    let around;
-    let aroundPoint;
-    if (options.around) {
-      around = import_lng_lat.default.convert(options.around);
-      aroundPoint = tr.locationPoint(around);
-    }
-    const currently = {
-      moving: this.moving,
-      zooming: this.zooming,
-      rotating: this.rotating,
-      pitching: this.pitching
-    };
-    this.zooming = this.zooming || zoom !== startZoom;
-    this.rotating = this.rotating || startBearing !== bearing;
-    this.pitching = this.pitching || pitch !== startPitch;
-    this.padding = !tr.isPaddingEqual(padding);
-    this.easeId = options.easeId;
-    this.prepareEase(eventData, options.noMoveStart, currently);
-    clearTimeout(this.easeEndTimeoutID);
-    this.ease((k) => {
-      if (this.zooming) {
-        tr.zoom = (0, import_util.interpolate)(startZoom, zoom, k);
+  }, {
+    key: "getCenter",
+    value: function getCenter() {
+      var _this$transform$cente = this.transform.center,
+          lng = _this$transform$cente.lng,
+          lat = _this$transform$cente.lat;
+      return new _lng_lat.default(lng, lat);
+    }
+  }, {
+    key: "getZoom",
+    value: function getZoom() {
+      return this.transform.zoom;
+    }
+  }, {
+    key: "getPitch",
+    value: function getPitch() {
+      return this.transform.pitch;
+    }
+  }, {
+    key: "setCenter",
+    value: function setCenter(center, eventData) {
+      return this.jumpTo({
+        center: center
+      }, eventData);
+    }
+  }, {
+    key: "setPitch",
+    value: function setPitch(pitch, eventData) {
+      this.jumpTo({
+        pitch: pitch
+      }, eventData);
+      return this;
+    }
+  }, {
+    key: "getBearing",
+    value: function getBearing() {
+      return this.transform.bearing;
+    }
+  }, {
+    key: "panTo",
+    value: function panTo(lnglat, options, eventData) {
+      return this.easeTo((0, _lodash.merge)({
+        center: lnglat
+      }, options), eventData);
+    }
+  }, {
+    key: "zoomOut",
+    value: function zoomOut(options, eventData) {
+      this.zoomTo(this.getZoom() - 1, options, eventData);
+      return this;
+    }
+  }, {
+    key: "setBearing",
+    value: function setBearing(bearing, eventData) {
+      this.jumpTo({
+        bearing: bearing
+      }, eventData);
+      return this;
+    }
+  }, {
+    key: "setZoom",
+    value: function setZoom(zoom, eventData) {
+      this.jumpTo({
+        zoom: zoom
+      }, eventData);
+      return this;
+    }
+  }, {
+    key: "zoomIn",
+    value: function zoomIn(options, eventData) {
+      this.zoomTo(this.getZoom() + 1, options, eventData);
+      return this;
+    }
+  }, {
+    key: "zoomTo",
+    value: function zoomTo(zoom, options, eventData) {
+      return this.easeTo((0, _lodash.merge)({
+        zoom: zoom
+      }, options), eventData);
+    }
+  }, {
+    key: "getPadding",
+    value: function getPadding() {
+      return this.transform.padding;
+    }
+  }, {
+    key: "setPadding",
+    value: function setPadding(padding, eventData) {
+      this.jumpTo({
+        padding: padding
+      }, eventData);
+      return this;
+    }
+  }, {
+    key: "rotateTo",
+    value: function rotateTo(bearing, options, eventData) {
+      return this.easeTo((0, _lodash.merge)({
+        bearing: bearing
+      }, options), eventData);
+    }
+  }, {
+    key: "resetNorth",
+    value: function resetNorth(options, eventData) {
+      this.rotateTo(0, (0, _lodash.merge)({
+        duration: 1000
+      }, options), eventData);
+      return this;
+    }
+  }, {
+    key: "resetNorthPitch",
+    value: function resetNorthPitch(options, eventData) {
+      this.easeTo((0, _lodash.merge)({
+        bearing: 0,
+        pitch: 0,
+        duration: 1000
+      }, options), eventData);
+      return this;
+    }
+  }, {
+    key: "fitBounds",
+    value: function fitBounds(bounds, options, eventData) {
+      return this.fitInternal( // @ts-ignore
+      this.cameraForBounds(bounds, options), options, eventData);
+    }
+  }, {
+    key: "cameraForBounds",
+    value: function cameraForBounds(bounds, options) {
+      bounds = _lng_lat_bounds.default.convert(bounds);
+      return this.cameraForBoxAndBearing(bounds.getNorthWest(), bounds.getSouthEast(), 0, // @ts-ignore
+      options);
+    }
+  }, {
+    key: "snapToNorth",
+    value: function snapToNorth(options, eventData) {
+      if (Math.abs(this.getBearing()) < this.bearingSnap) {
+        return this.resetNorth(options, eventData);
       }
-      if (this.rotating && this.rotateEnabled) {
-        tr.bearing = (0, import_util.interpolate)(startBearing, bearing, k);
+
+      return this;
+    }
+  }, {
+    key: "jumpTo",
+    value: function jumpTo() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var eventData = arguments.length > 1 ? arguments[1] : undefined;
+      this.stop();
+      var tr = this.transform;
+      var zoomChanged = false;
+      var bearingChanged = false;
+      var pitchChanged = false;
+
+      if (options.zoom && tr.zoom !== +options.zoom) {
+        zoomChanged = true;
+        tr.zoom = +options.zoom;
       }
-      if (this.pitching && this.pitchEnabled) {
-        tr.pitch = (0, import_util.interpolate)(startPitch, pitch, k);
+
+      if (options.center !== undefined) {
+        tr.center = _lng_lat.default.convert(options.center);
       }
-      if (this.padding) {
-        tr.interpolatePadding(startPadding, padding, k);
-        pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+
+      if (options.bearing && tr.bearing !== +options.bearing) {
+        bearingChanged = true;
+        tr.bearing = +options.bearing;
       }
-      if (around) {
-        tr.setLocationAtPoint(around, aroundPoint);
-      } else {
-        const scale = tr.zoomScale(tr.zoom - startZoom);
-        const base = zoom > startZoom ? Math.min(2, finalScale) : Math.max(0.5, finalScale);
-        const speedup = Math.pow(base, 1 - k);
-        const newCenter = tr.unproject(from.add(delta.mult(k * speedup)).mult(scale));
-        tr.setLocationAtPoint(tr.renderWorldCopies ? newCenter.wrap() : newCenter, pointAtOffset);
+
+      if (options.pitch && tr.pitch !== +options.pitch) {
+        pitchChanged = true;
+        tr.pitch = +options.pitch;
       }
-      this.fireMoveEvents(eventData);
-    }, (interruptingEaseId) => {
-      this.afterEase(eventData, interruptingEaseId);
-    }, options);
-    return this;
-  }
-  flyTo(options = {}, eventData) {
-    if (!options.essential && (0, import_util.prefersReducedMotion)()) {
-      const coercedOptions = (0, import_util.pick)(options, [
-        "center",
-        "zoom",
-        "bearing",
-        "pitch",
-        "around"
-      ]);
-      return this.jumpTo(coercedOptions, eventData);
-    }
-    this.stop();
-    options = (0, import_lodash.merge)({
-      offset: [0, 0],
-      speed: 1.2,
-      curve: 1.42,
-      easing: import_util.ease
-    }, options);
-    const tr = this.transform;
-    const startZoom = this.getZoom();
-    const startBearing = this.getBearing();
-    const startPitch = this.getPitch();
-    const startPadding = this.getPadding();
-    const zoom = options.zoom ? (0, import_util.clamp)(+options.zoom, tr.minZoom, tr.maxZoom) : startZoom;
-    const bearing = options.bearing ? this.normalizeBearing(options.bearing, startBearing) : startBearing;
-    const pitch = options.pitch ? +options.pitch : startPitch;
-    const padding = "padding" in options ? options.padding : tr.padding;
-    const scale = tr.zoomScale(zoom - startZoom);
-    const offsetAsPoint = import_point.default.convert(options.offset);
-    let pointAtOffset = tr.centerPoint.add(offsetAsPoint);
-    const locationAtOffset = tr.pointLocation(pointAtOffset);
-    const center = import_lng_lat.default.convert(options.center || locationAtOffset);
-    this.normalizeCenter(center);
-    const from = tr.project(locationAtOffset);
-    const delta = tr.project(center).sub(from);
-    let rho = options.curve;
-    const w0 = Math.max(tr.width, tr.height);
-    const w1 = w0 / scale;
-    const u1 = delta.mag();
-    if ("minZoom" in options) {
-      const minZoom = (0, import_util.clamp)(Math.min(options.minZoom, startZoom, zoom), tr.minZoom, tr.maxZoom);
-      const wMax = w0 / tr.zoomScale(minZoom - startZoom);
-      rho = Math.sqrt(wMax / u1 * 2);
-    }
-    const rho2 = rho * rho;
-    function r(i) {
-      const b = (w1 * w1 - w0 * w0 + (i ? -1 : 1) * rho2 * rho2 * u1 * u1) / (2 * (i ? w1 : w0) * rho2 * u1);
-      return Math.log(Math.sqrt(b * b + 1) - b);
-    }
-    function sinh(n) {
-      return (Math.exp(n) - Math.exp(-n)) / 2;
-    }
-    function cosh(n) {
-      return (Math.exp(n) + Math.exp(-n)) / 2;
-    }
-    function tanh(n) {
-      return sinh(n) / cosh(n);
-    }
-    const r0 = r(0);
-    let w = (s) => {
-      return cosh(r0) / cosh(r0 + rho * s);
-    };
-    let u = (s) => {
-      return w0 * ((cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2) / u1;
-    };
-    let S = (r(1) - r0) / rho;
-    if (Math.abs(u1) < 1e-6 || !isFinite(S)) {
-      if (Math.abs(w0 - w1) < 1e-6) {
-        return this.easeTo(options, eventData);
-      }
-      const k = w1 < w0 ? -1 : 1;
-      S = Math.abs(Math.log(w1 / w0)) / rho;
-      u = () => {
-        return 0;
-      };
-      w = (s) => {
-        return Math.exp(k * rho * s);
-      };
-    }
-    if ("duration" in options) {
-      options.duration = +options.duration;
-    } else {
-      const V = "screenSpeed" in options ? +options.screenSpeed / rho : +options.speed;
-      options.duration = 1e3 * S / V;
-    }
-    if (options.maxDuration && options.duration > options.maxDuration) {
-      options.duration = 0;
-    }
-    this.zooming = true;
-    this.rotating = startBearing !== bearing;
-    this.pitching = pitch !== startPitch;
-    this.padding = !tr.isPaddingEqual(padding);
-    this.prepareEase(eventData, false);
-    this.ease((k) => {
-      const s = k * S;
-      const easeScale = 1 / w(s);
-      tr.zoom = k === 1 ? zoom : startZoom + tr.scaleZoom(easeScale);
-      if (this.rotating) {
-        tr.bearing = (0, import_util.interpolate)(startBearing, bearing, k);
+
+      if (options.padding != null && !tr.isPaddingEqual(options.padding)) {
+        tr.padding = options.padding;
       }
-      if (this.pitching) {
-        tr.pitch = (0, import_util.interpolate)(startPitch, pitch, k);
+
+      this.emit('movestart', new _event.Event('movestart', eventData));
+      this.emit('move', new _event.Event('move', eventData));
+
+      if (zoomChanged) {
+        this.emit('zoomstart', new _event.Event('zoomstart', eventData));
+        this.emit('zoom', new _event.Event('zoom', eventData));
+        this.emit('zoomend', new _event.Event('zoomend', eventData));
       }
-      if (this.padding) {
-        tr.interpolatePadding(startPadding, padding, k);
-        pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+
+      if (bearingChanged) {
+        this.emit('rotatestart', new _event.Event('rotatestart', eventData));
+        this.emit('rotate', new _event.Event('rotate', eventData));
+        this.emit('rotateend', new _event.Event('rotateend', eventData));
       }
-      const newCenter = k === 1 ? center : tr.unproject(from.add(delta.mult(u(s))).mult(easeScale));
-      tr.setLocationAtPoint(tr.renderWorldCopies ? newCenter.wrap() : newCenter, pointAtOffset);
-      this.fireMoveEvents(eventData);
-    }, () => this.afterEase(eventData), options);
-    return this;
-  }
-  fitScreenCoordinates(p0, p1, bearing, options, eventData) {
-    return this.fitInternal(this.cameraForBoxAndBearing(this.transform.pointLocation(import_point.default.convert(p0)), this.transform.pointLocation(import_point.default.convert(p1)), bearing, options), options, eventData);
-  }
-  stop(allowGestures, easeId) {
-    if (this.easeFrameId) {
-      this.cancelRenderFrame(this.easeFrameId);
-      delete this.easeFrameId;
-      delete this.onEaseFrame;
-    }
-    if (this.onEaseEnd) {
-      const onEaseEnd = this.onEaseEnd;
-      delete this.onEaseEnd;
-      onEaseEnd.call(this, easeId);
-    }
-    return this;
-  }
-  normalizeBearing(bearing, currentBearing) {
-    bearing = (0, import_util.wrap)(bearing, -180, 180);
-    const diff = Math.abs(bearing - currentBearing);
-    if (Math.abs(bearing - 360 - currentBearing) < diff) {
-      bearing -= 360;
-    }
-    if (Math.abs(bearing + 360 - currentBearing) < diff) {
-      bearing += 360;
-    }
-    return bearing;
-  }
-  normalizeCenter(center) {
-    const tr = this.transform;
-    if (!tr.renderWorldCopies || tr.lngRange) {
-      return;
-    }
-    const delta = center.lng - tr.center.lng;
-    center.lng += delta > 180 ? -360 : delta < -180 ? 360 : 0;
-  }
-  fireMoveEvents(eventData) {
-    this.emit("move", new import_event.Event("move", eventData));
-    if (this.zooming) {
-      this.emit("zoom", new import_event.Event("zoom", eventData));
+
+      if (pitchChanged) {
+        this.emit('pitchstart', new _event.Event('pitchstart', eventData));
+        this.emit('pitch', new _event.Event('pitch', eventData));
+        this.emit('pitchend', new _event.Event('pitchend', eventData));
+      }
+
+      return this.emit('moveend', new _event.Event('moveend', eventData));
     }
-    if (this.rotating) {
-      this.emit("rotate", new import_event.Event("rotate", eventData));
+  }, {
+    key: "easeTo",
+    value: function easeTo() {
+      var _this2 = this;
+
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var eventData = arguments.length > 1 ? arguments[1] : undefined;
+      options = (0, _lodash.merge)({
+        offset: [0, 0],
+        duration: 500,
+        easing: _util.ease
+      }, options);
+
+      if (options.animate === false || !options.essential && (0, _util.prefersReducedMotion)()) {
+        options.duration = 0;
+      }
+
+      var tr = this.transform;
+      var startZoom = this.getZoom();
+      var startBearing = this.getBearing();
+      var startPitch = this.getPitch();
+      var startPadding = this.getPadding();
+      var zoom = options.zoom ? +options.zoom : startZoom;
+      var bearing = options.bearing ? this.normalizeBearing(options.bearing, startBearing) : startBearing;
+      var pitch = options.pitch ? +options.pitch : startPitch;
+      var padding = options.padding ? options.padding : tr.padding;
+
+      var offsetAsPoint = _point.default.convert(options.offset);
+
+      var pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+      var locationAtOffset = tr.pointLocation(pointAtOffset);
+
+      var center = _lng_lat.default.convert(options.center || locationAtOffset);
+
+      this.normalizeCenter(center);
+      var from = tr.project(locationAtOffset);
+      var delta = tr.project(center).sub(from);
+      var finalScale = tr.zoomScale(zoom - startZoom);
+      var around;
+      var aroundPoint;
+
+      if (options.around) {
+        around = _lng_lat.default.convert(options.around);
+        aroundPoint = tr.locationPoint(around);
+      }
+
+      var currently = {
+        moving: this.moving,
+        zooming: this.zooming,
+        rotating: this.rotating,
+        pitching: this.pitching
+      };
+      this.zooming = this.zooming || zoom !== startZoom;
+      this.rotating = this.rotating || startBearing !== bearing;
+      this.pitching = this.pitching || pitch !== startPitch;
+      this.padding = !tr.isPaddingEqual(padding);
+      this.easeId = options.easeId;
+      this.prepareEase(eventData, options.noMoveStart, currently);
+      clearTimeout(this.easeEndTimeoutID);
+      this.ease(function (k) {
+        if (_this2.zooming) {
+          tr.zoom = (0, _util.interpolate)(startZoom, zoom, k);
+        }
+
+        if (_this2.rotating && _this2.rotateEnabled) {
+          tr.bearing = (0, _util.interpolate)(startBearing, bearing, k);
+        }
+
+        if (_this2.pitching && _this2.pitchEnabled) {
+          tr.pitch = (0, _util.interpolate)(startPitch, pitch, k);
+        }
+
+        if (_this2.padding) {
+          tr.interpolatePadding(startPadding, padding, k); // When padding is being applied, Transform#centerPoint is changing continously,
+          // thus we need to recalculate offsetPoint every fra,e
+
+          pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+        }
+
+        if (around) {
+          tr.setLocationAtPoint(around, aroundPoint);
+        } else {
+          var scale = tr.zoomScale(tr.zoom - startZoom);
+          var base = zoom > startZoom ? Math.min(2, finalScale) : Math.max(0.5, finalScale);
+          var speedup = Math.pow(base, 1 - k);
+          var newCenter = tr.unproject(from.add(delta.mult(k * speedup)).mult(scale));
+          tr.setLocationAtPoint(tr.renderWorldCopies ? newCenter.wrap() : newCenter, pointAtOffset);
+        }
+
+        _this2.fireMoveEvents(eventData);
+      }, function (interruptingEaseId) {
+        _this2.afterEase(eventData, interruptingEaseId);
+      }, // @ts-ignore
+      options);
+      return this;
     }
-    if (this.pitching) {
-      this.emit("rotate", new import_event.Event("pitch", eventData));
+  }, {
+    key: "flyTo",
+    value: function flyTo() {
+      var _this3 = this;
+
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var eventData = arguments.length > 1 ? arguments[1] : undefined;
+
+      // Fall through to jumpTo if user has set prefers-reduced-motion
+      if (!options.essential && (0, _util.prefersReducedMotion)()) {
+        var coercedOptions = (0, _util.pick)(options, ['center', 'zoom', 'bearing', 'pitch', 'around']);
+        return this.jumpTo(coercedOptions, eventData);
+      }
+
+      this.stop();
+      options = (0, _lodash.merge)({
+        offset: [0, 0],
+        speed: 1.2,
+        curve: 1.42,
+        easing: _util.ease
+      }, options);
+      var tr = this.transform;
+      var startZoom = this.getZoom();
+      var startBearing = this.getBearing();
+      var startPitch = this.getPitch();
+      var startPadding = this.getPadding();
+      var zoom = options.zoom ? (0, _util.clamp)(+options.zoom, tr.minZoom, tr.maxZoom) : startZoom;
+      var bearing = options.bearing ? this.normalizeBearing(options.bearing, startBearing) : startBearing;
+      var pitch = options.pitch ? +options.pitch : startPitch;
+      var padding = 'padding' in options ? options.padding : tr.padding;
+      var scale = tr.zoomScale(zoom - startZoom);
+
+      var offsetAsPoint = _point.default.convert(options.offset);
+
+      var pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+      var locationAtOffset = tr.pointLocation(pointAtOffset);
+
+      var center = _lng_lat.default.convert(options.center || locationAtOffset);
+
+      this.normalizeCenter(center);
+      var from = tr.project(locationAtOffset);
+      var delta = tr.project(center).sub(from);
+      var rho = options.curve; // w₀: Initial visible span, measured in pixels at the initial scale.
+
+      var w0 = Math.max(tr.width, tr.height); // w₁: Final visible span, measured in pixels with respect to the initial scale.
+
+      var w1 = w0 / scale; // Length of the flight path as projected onto the ground plane, measured in pixels from
+      // the world image origin at the initial scale.
+
+      var u1 = delta.mag();
+
+      if ('minZoom' in options) {
+        var minZoom = (0, _util.clamp)(Math.min(options.minZoom, startZoom, zoom), tr.minZoom, tr.maxZoom); // w<sub>m</sub>: Maximum visible span, measured in pixels with respect to the initial
+        // scale.
+
+        var wMax = w0 / tr.zoomScale(minZoom - startZoom);
+        rho = Math.sqrt(wMax / u1 * 2);
+      } // ρ²
+
+
+      var rho2 = rho * rho;
+      /**
+       * rᵢ: Returns the zoom-out factor at one end of the animation.
+       *
+       * @param i 0 for the ascent or 1 for the descent.
+       * @private
+       */
+
+      function r(i) {
+        var b = (w1 * w1 - w0 * w0 + (i ? -1 : 1) * rho2 * rho2 * u1 * u1) / (2 * (i ? w1 : w0) * rho2 * u1);
+        return Math.log(Math.sqrt(b * b + 1) - b);
+      }
+
+      function sinh(n) {
+        return (Math.exp(n) - Math.exp(-n)) / 2;
+      }
+
+      function cosh(n) {
+        return (Math.exp(n) + Math.exp(-n)) / 2;
+      }
+
+      function tanh(n) {
+        return sinh(n) / cosh(n);
+      } // r₀: Zoom-out factor during ascent.
+
+
+      var r0 = r(0); // w(s): Returns the visible span on the ground, measured in pixels with respect to the
+      // initial scale. Assumes an angular field of view of 2 arctan ½ ≈ 53°.
+
+      var w = function w(s) {
+        return cosh(r0) / cosh(r0 + rho * s);
+      }; // u(s): Returns the distance along the flight path as projected onto the ground plane,
+      // measured in pixels from the world image origin at the initial scale.
+
+
+      var u = function u(s) {
+        return w0 * ((cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2) / u1;
+      }; // S: Total length of the flight path, measured in ρ-screenfuls.
+
+
+      var S = (r(1) - r0) / rho; // When u₀ = u₁, the optimal path doesn’t require both ascent and descent.
+
+      if (Math.abs(u1) < 0.000001 || !isFinite(S)) {
+        // Perform a more or less instantaneous transition if the path is too short.
+        if (Math.abs(w0 - w1) < 0.000001) {
+          return this.easeTo(options, eventData);
+        }
+
+        var k = w1 < w0 ? -1 : 1;
+        S = Math.abs(Math.log(w1 / w0)) / rho;
+
+        u = function u() {
+          return 0;
+        };
+
+        w = function w(s) {
+          return Math.exp(k * rho * s);
+        };
+      }
+
+      if ('duration' in options) {
+        options.duration = +options.duration;
+      } else {
+        var V = 'screenSpeed' in options ? +options.screenSpeed / rho : +options.speed;
+        options.duration = 1000 * S / V;
+      }
+
+      if (options.maxDuration && options.duration > options.maxDuration) {
+        options.duration = 0;
+      }
+
+      this.zooming = true;
+      this.rotating = startBearing !== bearing;
+      this.pitching = pitch !== startPitch;
+      this.padding = !tr.isPaddingEqual(padding);
+      this.prepareEase(eventData, false);
+      this.ease(function (k) {
+        // s: The distance traveled along the flight path, measured in ρ-screenfuls.
+        var s = k * S; // @ts-ignore
+
+        var easeScale = 1 / w(s);
+        tr.zoom = k === 1 ? zoom : startZoom + tr.scaleZoom(easeScale);
+
+        if (_this3.rotating) {
+          tr.bearing = (0, _util.interpolate)(startBearing, bearing, k);
+        }
+
+        if (_this3.pitching) {
+          tr.pitch = (0, _util.interpolate)(startPitch, pitch, k);
+        }
+
+        if (_this3.padding) {
+          tr.interpolatePadding(startPadding, padding, k); // When padding is being applied, Transform#centerPoint is changing continously,
+          // thus we need to recalculate offsetPoint every frame
+
+          pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+        }
+
+        var newCenter = k === 1 ? center : tr.unproject(from.add(delta.mult(u(s))).mult(easeScale));
+        tr.setLocationAtPoint(tr.renderWorldCopies ? newCenter.wrap() : newCenter, pointAtOffset);
+
+        _this3.fireMoveEvents(eventData);
+      }, function () {
+        return _this3.afterEase(eventData);
+      }, options);
+      return this;
     }
-  }
-  prepareEase(eventData, noMoveStart = false, currently = {}) {
-    this.moving = true;
-    if (!noMoveStart && !currently.moving) {
-      this.emit("movestart", new import_event.Event("movestart", eventData));
+  }, {
+    key: "fitScreenCoordinates",
+    value: function fitScreenCoordinates(p0, p1, bearing, options, eventData) {
+      return this.fitInternal( // @ts-ignore
+      this.cameraForBoxAndBearing(this.transform.pointLocation(_point.default.convert(p0)), this.transform.pointLocation(_point.default.convert(p1)), bearing, // @ts-ignore
+      options), options, eventData);
+    }
+  }, {
+    key: "stop",
+    value: function stop(allowGestures, easeId) {
+      if (this.easeFrameId) {
+        this.cancelRenderFrame(this.easeFrameId); // @ts-ignore
+
+        delete this.easeFrameId; // @ts-ignore
+
+        delete this.onEaseFrame;
+      }
+
+      if (this.onEaseEnd) {
+        // The _onEaseEnd function might emit events which trigger new
+        // animation, which sets a new _onEaseEnd. Ensure we don't delete
+        // it unintentionally.
+        var onEaseEnd = this.onEaseEnd; // @ts-ignore
+
+        delete this.onEaseEnd;
+        onEaseEnd.call(this, easeId);
+      } // if (!allowGestures) {
+      //     const handlers = (this: any).handlers;
+      //     if (handlers) handlers.stop();
+      // }
+
+
+      return this;
     }
-    if (this.zooming && !currently.zooming) {
-      this.emit("zoomstart", new import_event.Event("zoomstart", eventData));
+  }, {
+    key: "normalizeBearing",
+    value: function normalizeBearing(bearing, currentBearing) {
+      bearing = (0, _util.wrap)(bearing, -180, 180);
+      var diff = Math.abs(bearing - currentBearing);
+
+      if (Math.abs(bearing - 360 - currentBearing) < diff) {
+        bearing -= 360;
+      }
+
+      if (Math.abs(bearing + 360 - currentBearing) < diff) {
+        bearing += 360;
+      }
+
+      return bearing;
     }
-    if (this.rotating && !currently.rotating) {
-      this.emit("rotatestart", new import_event.Event("rotatestart", eventData));
+  }, {
+    key: "normalizeCenter",
+    value: function normalizeCenter(center) {
+      var tr = this.transform;
+
+      if (!tr.renderWorldCopies || tr.lngRange) {
+        return;
+      }
+
+      var delta = center.lng - tr.center.lng;
+      center.lng += delta > 180 ? -360 : delta < -180 ? 360 : 0;
     }
-    if (this.pitching && !currently.pitching) {
-      this.emit("pitchstart", new import_event.Event("pitchstart", eventData));
+  }, {
+    key: "fireMoveEvents",
+    value: function fireMoveEvents(eventData) {
+      this.emit('move', new _event.Event('move', eventData));
+
+      if (this.zooming) {
+        this.emit('zoom', new _event.Event('zoom', eventData));
+      }
+
+      if (this.rotating) {
+        this.emit('rotate', new _event.Event('rotate', eventData));
+      }
+
+      if (this.pitching) {
+        this.emit('rotate', new _event.Event('pitch', eventData));
+      }
     }
-  }
-  afterEase(eventData, easeId) {
-    if (this.easeId && easeId && this.easeId === easeId) {
-      return;
+  }, {
+    key: "prepareEase",
+    value: function prepareEase(eventData) {
+      var noMoveStart = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var currently = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      this.moving = true;
+
+      if (!noMoveStart && !currently.moving) {
+        this.emit('movestart', new _event.Event('movestart', eventData));
+      }
+
+      if (this.zooming && !currently.zooming) {
+        this.emit('zoomstart', new _event.Event('zoomstart', eventData));
+      }
+
+      if (this.rotating && !currently.rotating) {
+        this.emit('rotatestart', new _event.Event('rotatestart', eventData));
+      }
+
+      if (this.pitching && !currently.pitching) {
+        this.emit('pitchstart', new _event.Event('pitchstart', eventData));
+      }
     }
-    delete this.easeId;
-    const wasZooming = this.zooming;
-    const wasRotating = this.rotating;
-    const wasPitching = this.pitching;
-    this.moving = false;
-    this.zooming = false;
-    this.rotating = false;
-    this.pitching = false;
-    this.padding = false;
-    if (wasZooming) {
-      this.emit("zoomend", new import_event.Event("zoomend", eventData));
-    }
-    if (wasRotating) {
-      this.emit("rotateend", new import_event.Event("rotateend", eventData));
-    }
-    if (wasPitching) {
-      this.emit("pitchend", new import_event.Event("pitchend", eventData));
-    }
-    this.emit("moveend", new import_event.Event("moveend", eventData));
-  }
-  ease(frame, finish, options) {
-    if (options.animate === false || options.duration === 0) {
-      frame(1);
-      finish();
-    } else {
-      this.easeStart = (0, import_util.now)();
-      this.easeOptions = options;
-      this.onEaseFrame = frame;
-      this.onEaseEnd = finish;
-      this.easeFrameId = this.requestRenderFrame(this.renderFrameCallback);
+  }, {
+    key: "afterEase",
+    value: function afterEase(eventData, easeId) {
+      // if this easing is being stopped to start another easing with
+      // the same id then don't fire any events to avoid extra start/stop events
+      if (this.easeId && easeId && this.easeId === easeId) {
+        return;
+      } // @ts-ignore
+
+
+      delete this.easeId;
+      var wasZooming = this.zooming;
+      var wasRotating = this.rotating;
+      var wasPitching = this.pitching;
+      this.moving = false;
+      this.zooming = false;
+      this.rotating = false;
+      this.pitching = false;
+      this.padding = false;
+
+      if (wasZooming) {
+        this.emit('zoomend', new _event.Event('zoomend', eventData));
+      }
+
+      if (wasRotating) {
+        this.emit('rotateend', new _event.Event('rotateend', eventData));
+      }
+
+      if (wasPitching) {
+        this.emit('pitchend', new _event.Event('pitchend', eventData));
+      }
+
+      this.emit('moveend', new _event.Event('moveend', eventData));
+    }
+  }, {
+    key: "ease",
+    value: function ease(frame, finish, options) {
+      if (options.animate === false || options.duration === 0) {
+        frame(1);
+        finish();
+      } else {
+        this.easeStart = (0, _util.now)();
+        this.easeOptions = options;
+        this.onEaseFrame = frame;
+        this.onEaseEnd = finish;
+        this.easeFrameId = this.requestRenderFrame(this.renderFrameCallback);
+      }
     }
-  }
-  cameraForBoxAndBearing(p0, p1, bearing, options) {
-    const defaultPadding = {
-      top: 0,
-      bottom: 0,
-      right: 0,
-      left: 0
-    };
-    options = (0, import_lodash.merge)({
-      padding: defaultPadding,
-      offset: [0, 0],
-      maxZoom: this.transform.maxZoom
-    }, options);
-    if (typeof options.padding === "number") {
-      const p = options.padding;
-      options.padding = {
-        top: p,
-        bottom: p,
-        right: p,
-        left: p
+  }, {
+    key: "cameraForBoxAndBearing",
+    value: function cameraForBoxAndBearing(p0, p1, bearing, options) {
+      var defaultPadding = {
+        top: 0,
+        bottom: 0,
+        right: 0,
+        left: 0
+      };
+      options = (0, _lodash.merge)({
+        padding: defaultPadding,
+        offset: [0, 0],
+        maxZoom: this.transform.maxZoom
+      }, options);
+
+      if (typeof options.padding === 'number') {
+        var p = options.padding;
+        options.padding = {
+          top: p,
+          bottom: p,
+          right: p,
+          left: p
+        };
+      }
+
+      options.padding = (0, _lodash.merge)(defaultPadding, options.padding);
+      var tr = this.transform;
+      var edgePadding = tr.padding; // We want to calculate the upper right and lower left of the box defined by p0 and p1
+      // in a coordinate system rotate to match the destination bearing.
+
+      var p0world = tr.project(_lng_lat.default.convert(p0));
+      var p1world = tr.project(_lng_lat.default.convert(p1));
+      var p0rotated = p0world.rotate(-bearing * Math.PI / 180);
+      var p1rotated = p1world.rotate(-bearing * Math.PI / 180);
+      var upperRight = new _point.default(Math.max(p0rotated.x, p1rotated.x), Math.max(p0rotated.y, p1rotated.y));
+      var lowerLeft = new _point.default(Math.min(p0rotated.x, p1rotated.x), Math.min(p0rotated.y, p1rotated.y)); // Calculate zoom: consider the original bbox and padding.
+
+      var size = upperRight.sub(lowerLeft);
+      var scaleX = (tr.width - ( // @ts-ignore
+      edgePadding.left + // @ts-ignore
+      edgePadding.right + // @ts-ignore
+      options.padding.left + // @ts-ignore
+      options.padding.right)) / size.x;
+      var scaleY = (tr.height - ( // @ts-ignore
+      edgePadding.top + // @ts-ignore
+      edgePadding.bottom + // @ts-ignore
+      options.padding.top + // @ts-ignore
+      options.padding.bottom)) / size.y;
+
+      if (scaleY < 0 || scaleX < 0) {
+        return;
+      }
+
+      var zoom = Math.min(tr.scaleZoom(tr.scale * Math.min(scaleX, scaleY)), options.maxZoom); // Calculate center: apply the zoom, the configured offset, as well as offset that exists as a result of padding.
+
+      var offset = _point.default.convert(options.offset); // @ts-ignore
+
+
+      var paddingOffsetX = (options.padding.left - options.padding.right) / 2; // @ts-ignore
+
+      var paddingOffsetY = (options.padding.top - options.padding.bottom) / 2;
+      var offsetAtInitialZoom = new _point.default(offset.x + paddingOffsetX, offset.y + paddingOffsetY);
+      var offsetAtFinalZoom = offsetAtInitialZoom.mult(tr.scale / tr.zoomScale(zoom));
+      var center = tr.unproject(p0world.add(p1world).div(2).sub(offsetAtFinalZoom));
+      return {
+        center: center,
+        zoom: zoom,
+        bearing: bearing
       };
     }
-    options.padding = (0, import_lodash.merge)(defaultPadding, options.padding);
-    const tr = this.transform;
-    const edgePadding = tr.padding;
-    const p0world = tr.project(import_lng_lat.default.convert(p0));
-    const p1world = tr.project(import_lng_lat.default.convert(p1));
-    const p0rotated = p0world.rotate(-bearing * Math.PI / 180);
-    const p1rotated = p1world.rotate(-bearing * Math.PI / 180);
-    const upperRight = new import_point.default(Math.max(p0rotated.x, p1rotated.x), Math.max(p0rotated.y, p1rotated.y));
-    const lowerLeft = new import_point.default(Math.min(p0rotated.x, p1rotated.x), Math.min(p0rotated.y, p1rotated.y));
-    const size = upperRight.sub(lowerLeft);
-    const scaleX = (tr.width - (edgePadding.left + edgePadding.right + options.padding.left + options.padding.right)) / size.x;
-    const scaleY = (tr.height - (edgePadding.top + edgePadding.bottom + options.padding.top + options.padding.bottom)) / size.y;
-    if (scaleY < 0 || scaleX < 0) {
-      return;
-    }
-    const zoom = Math.min(tr.scaleZoom(tr.scale * Math.min(scaleX, scaleY)), options.maxZoom);
-    const offset = import_point.default.convert(options.offset);
-    const paddingOffsetX = (options.padding.left - options.padding.right) / 2;
-    const paddingOffsetY = (options.padding.top - options.padding.bottom) / 2;
-    const offsetAtInitialZoom = new import_point.default(offset.x + paddingOffsetX, offset.y + paddingOffsetY);
-    const offsetAtFinalZoom = offsetAtInitialZoom.mult(tr.scale / tr.zoomScale(zoom));
-    const center = tr.unproject(p0world.add(p1world).div(2).sub(offsetAtFinalZoom));
-    return {
-      center,
-      zoom,
-      bearing
-    };
-  }
-  fitInternal(calculatedOptions, options, eventData) {
-    if (!calculatedOptions) {
-      return this;
+  }, {
+    key: "fitInternal",
+    value: function fitInternal(calculatedOptions, options, eventData) {
+      // cameraForBounds warns + returns undefined if unable to fit:
+      if (!calculatedOptions) {
+        return this;
+      }
+
+      options = (0, _lodash.merge)(calculatedOptions, options); // Explictly remove the padding field because, calculatedOptions already accounts for padding by setting zoom and center accordingly.
+
+      delete options.padding; // @ts-ignore
+
+      return options.linear ? this.easeTo(options, eventData) : this.flyTo(options, eventData);
     }
-    options = (0, import_lodash.merge)(calculatedOptions, options);
-    delete options.padding;
-    return options.linear ? this.easeTo(options, eventData) : this.flyTo(options, eventData);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+  }]);
+  return Camera;
+}(_eventemitter.EventEmitter);
+
+exports.default = Camera;