@antv/l7-map 2.21.1 → 2.21.3

package/es/camera.js

@@ -1,12 +1,4 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(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; } }
 // @ts-ignore
 import { lodashUtil } from '@antv/l7-utils';
 import { EventEmitter } from 'eventemitter3';
@@ -16,703 +8,632 @@ import Point from "./geo/point";
 import Transform from "./geo/transform";
 import { Event } from "./handler/events/event";
 import { clamp, ease as defaultEasing, extend, interpolate, now, pick, prefersReducedMotion, wrap } from "./util";
-var merge = lodashUtil.merge;
-var Camera = /*#__PURE__*/function (_EventEmitter) {
-  _inherits(Camera, _EventEmitter);
-  var _super = _createSuper(Camera);
-  // public requestRenderFrame: (_: any) => number;
-  // public cancelRenderFrame: (_: number) => void;
-
-  function Camera(options) {
-    var _this;
-    _classCallCheck(this, Camera);
-    _this = _super.call(this);
-    _defineProperty(_assertThisInitialized(_this), "renderFrameCallback", function () {
-      var t = Math.min((now() - _this.easeStart) / _this.easeOptions.duration, 1);
-      _this.onEaseFrame(_this.easeOptions.easing(t));
+const {
+  merge
+} = lodashUtil;
+export default class Camera extends EventEmitter {
+  constructor(options) {
+    super();
+    _defineProperty(this, "transform", void 0);
+    // public requestRenderFrame: (_: any) => number;
+    // public cancelRenderFrame: (_: number) => void;
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "moving", void 0);
+    _defineProperty(this, "zooming", void 0);
+    _defineProperty(this, "rotating", void 0);
+    _defineProperty(this, "pitching", void 0);
+    _defineProperty(this, "padding", void 0);
+    _defineProperty(this, "bearingSnap", void 0);
+    _defineProperty(this, "easeEndTimeoutID", void 0);
+    _defineProperty(this, "easeStart", void 0);
+    _defineProperty(this, "easeOptions", void 0);
+    _defineProperty(this, "easeId", void 0);
+    _defineProperty(this, "onEaseFrame", void 0);
+    _defineProperty(this, "onEaseEnd", void 0);
+    _defineProperty(this, "easeFrameId", void 0);
+    _defineProperty(this, "pitchEnabled", void 0);
+    _defineProperty(this, "rotateEnabled", void 0);
+    _defineProperty(this, "renderFrameCallback", () => {
+      const t = Math.min((now() - this.easeStart) / this.easeOptions.duration, 1);
+      this.onEaseFrame(this.easeOptions.easing(t));
       if (t < 1) {
         // this.easeFrameId = window.requestAnimationFrame(this.renderFrameCallback);
-        _this.easeFrameId = _this.requestRenderFrame(_this.renderFrameCallback);
+        this.easeFrameId = this.requestRenderFrame(this.renderFrameCallback);
       } else {
-        _this.stop();
+        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(minZoom, maxZoom, minPitch, maxPitch, renderWorldCopies);
-    return _this;
+    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 Transform(minZoom, maxZoom, minPitch, maxPitch, renderWorldCopies);
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _createClass(Camera, [{
-    key: "requestRenderFrame",
-    value: function requestRenderFrame(cb) {
-      return 0;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "cancelRenderFrame",
-    value: function cancelRenderFrame(_) {
-      return;
-    }
-  }, {
-    key: "getCenter",
-    value: function getCenter() {
-      var _this$transform$cente = this.transform.center,
-        lng = _this$transform$cente.lng,
-        lat = _this$transform$cente.lat;
-      return new LngLat(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(merge({
-        center: lnglat
-      }, options), eventData);
-    }
-  }, {
-    key: "panBy",
-    value: function panBy(offset, options, eventData) {
-      offset = Point.convert(offset).mult(-1);
-      return this.panTo(this.transform.center, extend({
-        offset: offset
-      }, 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(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(merge({
-        bearing: bearing
-      }, options), eventData);
-    }
-  }, {
-    key: "resetNorth",
-    value: function resetNorth(options, eventData) {
-      this.rotateTo(0, merge({
-        duration: 1000
-      }, options), eventData);
-      return this;
-    }
-  }, {
-    key: "resetNorthPitch",
-    value: function resetNorthPitch(options, eventData) {
-      this.easeTo(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 = LngLatBounds.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);
-      }
-      return this;
+  requestRenderFrame(cb) {
+    return 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  cancelRenderFrame(_) {
+    return;
+  }
+  getCenter() {
+    const {
+      lng,
+      lat
+    } = this.transform.center;
+    return new LngLat(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(merge({
+      center: lnglat
+    }, options), eventData);
+  }
+  panBy(offset, options, eventData) {
+    offset = Point.convert(offset).mult(-1);
+    return this.panTo(this.transform.center, extend({
+      offset
+    }, 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(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(merge({
+      bearing
+    }, options), eventData);
+  }
+  resetNorth(options, eventData) {
+    this.rotateTo(0, merge({
+      duration: 1000
+    }, options), eventData);
+    return this;
+  }
+  resetNorthPitch(options, eventData) {
+    this.easeTo(merge({
+      bearing: 0,
+      pitch: 0,
+      duration: 1000
+    }, options), eventData);
+    return this;
+  }
+  fitBounds(bounds, options, eventData) {
+    return this.fitInternal(
+    // @ts-ignore
+    this.cameraForBounds(bounds, options), options, eventData);
+  }
+  cameraForBounds(bounds, options) {
+    bounds = LngLatBounds.convert(bounds);
+    return this.cameraForBoxAndBearing(bounds.getNorthWest(), bounds.getSouthEast(), 0,
+    // @ts-ignore
+    options);
+  }
+  snapToNorth(options, eventData) {
+    if (Math.abs(this.getBearing()) < this.bearingSnap) {
+      return this.resetNorth(options, eventData);
     }
-  }, {
-    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 !== undefined && tr.zoom !== +options.zoom) {
-        zoomChanged = true;
-        tr.zoom = +options.zoom;
-      }
-      if (options.center !== undefined) {
-        tr.center = LngLat.convert(options.center);
-      }
-      if (options.bearing !== undefined && tr.bearing !== +options.bearing) {
-        bearingChanged = true;
-        tr.bearing = +options.bearing;
-      }
-      if (options.pitch !== undefined && tr.pitch !== +options.pitch) {
-        pitchChanged = true;
-        tr.pitch = +options.pitch;
-      }
-      if (options.padding !== undefined && !tr.isPaddingEqual(options.padding)) {
-        tr.padding = options.padding;
-      }
-      this.emit('movestart', new Event('movestart', eventData));
-      this.emit('move', new Event('move', eventData));
-      if (zoomChanged) {
-        this.emit('zoomstart', new Event('zoomstart', eventData));
-        this.emit('zoom', new Event('zoom', eventData));
-        this.emit('zoomend', new Event('zoomend', eventData));
-      }
-      if (bearingChanged) {
-        this.emit('rotatestart', new Event('rotatestart', eventData));
-        this.emit('rotate', new Event('rotate', eventData));
-        this.emit('rotateend', new Event('rotateend', eventData));
+    return this;
+  }
+  jumpTo(options = {}, eventData) {
+    this.stop();
+    const tr = this.transform;
+    let zoomChanged = false;
+    let bearingChanged = false;
+    let pitchChanged = false;
+    if (options.zoom !== undefined && tr.zoom !== +options.zoom) {
+      zoomChanged = true;
+      tr.zoom = +options.zoom;
+    }
+    if (options.center !== undefined) {
+      tr.center = LngLat.convert(options.center);
+    }
+    if (options.bearing !== undefined && tr.bearing !== +options.bearing) {
+      bearingChanged = true;
+      tr.bearing = +options.bearing;
+    }
+    if (options.pitch !== undefined && tr.pitch !== +options.pitch) {
+      pitchChanged = true;
+      tr.pitch = +options.pitch;
+    }
+    if (options.padding !== undefined && !tr.isPaddingEqual(options.padding)) {
+      tr.padding = options.padding;
+    }
+    this.emit('movestart', new Event('movestart', eventData));
+    this.emit('move', new Event('move', eventData));
+    if (zoomChanged) {
+      this.emit('zoomstart', new Event('zoomstart', eventData));
+      this.emit('zoom', new Event('zoom', eventData));
+      this.emit('zoomend', new Event('zoomend', eventData));
+    }
+    if (bearingChanged) {
+      this.emit('rotatestart', new Event('rotatestart', eventData));
+      this.emit('rotate', new Event('rotate', eventData));
+      this.emit('rotateend', new Event('rotateend', eventData));
+    }
+    if (pitchChanged) {
+      this.emit('pitchstart', new Event('pitchstart', eventData));
+      this.emit('pitch', new Event('pitch', eventData));
+      this.emit('pitchend', new Event('pitchend', eventData));
+    }
+    return this.emit('moveend', new Event('moveend', eventData));
+  }
+  easeTo(options = {}, eventData) {
+    options = merge({
+      offset: [0, 0],
+      duration: 500,
+      easing: defaultEasing
+    }, options);
+    if (options.animate === false || !options.essential && 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 = Point.convert(options.offset);
+    let pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+    const locationAtOffset = tr.pointLocation(pointAtOffset);
+    const center = LngLat.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 = LngLat.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 = interpolate(startZoom, zoom, k);
       }
-      if (pitchChanged) {
-        this.emit('pitchstart', new Event('pitchstart', eventData));
-        this.emit('pitch', new Event('pitch', eventData));
-        this.emit('pitchend', new Event('pitchend', eventData));
+      if (this.rotating && this.rotateEnabled) {
+        tr.bearing = interpolate(startBearing, bearing, k);
       }
-      return this.emit('moveend', new Event('moveend', 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 = merge({
-        offset: [0, 0],
-        duration: 500,
-        easing: defaultEasing
-      }, options);
-      if (options.animate === false || !options.essential && prefersReducedMotion()) {
-        options.duration = 0;
+      if (this.pitching && this.pitchEnabled) {
+        tr.pitch = interpolate(startPitch, pitch, k);
       }
-      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.convert(options.offset);
-      var pointAtOffset = tr.centerPoint.add(offsetAsPoint);
-      var locationAtOffset = tr.pointLocation(pointAtOffset);
-      var center = LngLat.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 = LngLat.convert(options.around);
-        aroundPoint = tr.locationPoint(around);
+      if (this.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);
       }
-      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 = interpolate(startZoom, zoom, k);
-        }
-        if (_this2.rotating && _this2.rotateEnabled) {
-          tr.bearing = interpolate(startBearing, bearing, k);
-        }
-        if (_this2.pitching && _this2.pitchEnabled) {
-          tr.pitch = 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;
-    }
-  }, {
-    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 && prefersReducedMotion()) {
-        var coercedOptions = pick(options, ['center', 'zoom', 'bearing', 'pitch', 'around']);
-        return this.jumpTo(coercedOptions, eventData);
+      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);
       }
-      this.stop();
-      options = merge({
-        offset: [0, 0],
-        speed: 1.2,
-        curve: 1.42,
-        easing: defaultEasing
-      }, 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 ? 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.convert(options.offset);
-      var pointAtOffset = tr.centerPoint.add(offsetAsPoint);
-      var locationAtOffset = tr.pointLocation(pointAtOffset);
-      var center = LngLat.convert(options.center || locationAtOffset);
-      this.normalizeCenter(center);
-      var from = tr.project(locationAtOffset);
-      var delta = tr.project(center).sub(from);
-      var rho = options.curve;
+      this.fireMoveEvents(eventData);
+    }, interruptingEaseId => {
+      this.afterEase(eventData, interruptingEaseId);
+    },
+    // @ts-ignore
+    options);
+    return this;
+  }
+  flyTo(options = {}, eventData) {
+    // Fall through to jumpTo if user has set prefers-reduced-motion
+    if (!options.essential && prefersReducedMotion()) {
+      const coercedOptions = pick(options, ['center', 'zoom', 'bearing', 'pitch', 'around']);
+      return this.jumpTo(coercedOptions, eventData);
+    }
+    this.stop();
+    options = merge({
+      offset: [0, 0],
+      speed: 1.2,
+      curve: 1.42,
+      easing: defaultEasing
+    }, 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 ? 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 = Point.convert(options.offset);
+    let pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+    const locationAtOffset = tr.pointLocation(pointAtOffset);
+    const center = LngLat.convert(options.center || locationAtOffset);
+    this.normalizeCenter(center);
+    const from = tr.project(locationAtOffset);
+    const delta = tr.project(center).sub(from);
+    let 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 = 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);
-      }
+    // w₀: Initial visible span, measured in pixels at the initial scale.
+    const w0 = Math.max(tr.width, tr.height);
+    // w₁: Final visible span, measured in pixels with respect to the initial scale.
+    const 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.
+    const u1 = delta.mag();
+    if ('minZoom' in options) {
+      const minZoom = 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.
+      const wMax = w0 / tr.zoomScale(minZoom - startZoom);
+      rho = Math.sqrt(wMax / u1 * 2);
+    }
 
-      // ρ²
-      var rho2 = rho * rho;
+    // ρ²
+    const 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ᵢ: 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) {
+      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);
+    }
 
-      // r₀: Zoom-out factor during ascent.
-      var r0 = r(0);
+    // r₀: Zoom-out factor during ascent.
+    const 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);
-      };
+    // 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°.
+    let 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;
-      };
+    // 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.
+    let 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;
+    // S: Total length of the flight path, measured in ρ-screenfuls.
+    let 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 = interpolate(startBearing, bearing, k);
-        }
-        if (_this3.pitching) {
-          tr.pitch = 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;
+    // 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);
+      }
+      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);
+      };
     }
-  }, {
-    key: "fitScreenCoordinates",
-    value: function fitScreenCoordinates(p0, p1, bearing, options, eventData) {
-      return this.fitInternal(
-      // @ts-ignore
-      this.cameraForBoxAndBearing(this.transform.pointLocation(Point.convert(p0)), this.transform.pointLocation(Point.convert(p1)), bearing,
+    if ('duration' in options) {
+      options.duration = +options.duration;
+    } else {
+      const 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(k => {
+      // s: The distance traveled along the flight path, measured in ρ-screenfuls.
+      const s = k * S;
       // @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;
-    }
-  }, {
-    key: "normalizeBearing",
-    value: function normalizeBearing(bearing, currentBearing) {
-      bearing = 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;
-    }
-  }, {
-    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;
-    }
-  }, {
-    key: "fireMoveEvents",
-    value: function fireMoveEvents(eventData) {
-      this.emit('move', new Event('move', eventData));
-      if (this.zooming) {
-        this.emit('zoom', new Event('zoom', eventData));
-      }
+      const easeScale = 1 / w(s);
+      tr.zoom = k === 1 ? zoom : startZoom + tr.scaleZoom(easeScale);
       if (this.rotating) {
-        this.emit('rotate', new Event('rotate', eventData));
+        tr.bearing = interpolate(startBearing, bearing, k);
       }
       if (this.pitching) {
-        this.emit('rotate', new Event('pitch', eventData));
-      }
-    }
-  }, {
-    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('movestart', eventData));
-      }
-      if (this.zooming && !currently.zooming) {
-        this.emit('zoomstart', new Event('zoomstart', eventData));
-      }
-      if (this.rotating && !currently.rotating) {
-        this.emit('rotatestart', new Event('rotatestart', eventData));
-      }
-      if (this.pitching && !currently.pitching) {
-        this.emit('pitchstart', new Event('pitchstart', eventData));
-      }
+        tr.pitch = interpolate(startPitch, pitch, k);
+      }
+      if (this.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);
+      }
+      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(
+    // @ts-ignore
+    this.cameraForBoxAndBearing(this.transform.pointLocation(Point.convert(p0)), this.transform.pointLocation(Point.convert(p1)), bearing,
+    // @ts-ignore
+    options), options, eventData);
+  }
+  stop(allowGestures, easeId) {
+    if (this.easeFrameId) {
+      this.cancelRenderFrame(this.easeFrameId);
+      // @ts-ignore
+      delete this.easeFrameId;
+      // @ts-ignore
+      delete this.onEaseFrame;
     }
-  }, {
-    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;
-      }
+    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.
+      const onEaseEnd = this.onEaseEnd;
       // @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('zoomend', eventData));
-      }
-      if (wasRotating) {
-        this.emit('rotateend', new Event('rotateend', eventData));
-      }
-      if (wasPitching) {
-        this.emit('pitchend', new Event('pitchend', eventData));
-      }
-      this.emit('moveend', new Event('moveend', eventData));
-    }
-  }, {
-    key: "ease",
-    value: function ease(frame, finish, options) {
-      if (options.animate === false || options.duration === 0) {
-        frame(1);
-        finish();
-      } else {
-        this.easeStart = now();
-        this.easeOptions = options;
-        this.onEaseFrame = frame;
-        this.onEaseEnd = finish;
-        this.easeFrameId = this.requestRenderFrame(this.renderFrameCallback);
-      }
+      delete this.onEaseEnd;
+      onEaseEnd.call(this, easeId);
+    }
+    // if (!allowGestures) {
+    //     const handlers = (this: any).handlers;
+    //     if (handlers) handlers.stop();
+    // }
+    return this;
+  }
+  normalizeBearing(bearing, currentBearing) {
+    bearing = 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 Event('move', eventData));
+    if (this.zooming) {
+      this.emit('zoom', new Event('zoom', eventData));
+    }
+    if (this.rotating) {
+      this.emit('rotate', new Event('rotate', eventData));
+    }
+    if (this.pitching) {
+      this.emit('rotate', new Event('pitch', eventData));
+    }
+  }
+  prepareEase(eventData, noMoveStart = false, currently = {}) {
+    this.moving = true;
+    if (!noMoveStart && !currently.moving) {
+      this.emit('movestart', new Event('movestart', eventData));
+    }
+    if (this.zooming && !currently.zooming) {
+      this.emit('zoomstart', new Event('zoomstart', eventData));
+    }
+    if (this.rotating && !currently.rotating) {
+      this.emit('rotatestart', new Event('rotatestart', eventData));
     }
-  }, {
-    key: "cameraForBoxAndBearing",
-    value: function cameraForBoxAndBearing(p0, p1, bearing, options) {
-      var defaultPadding = {
-        top: 0,
-        bottom: 0,
-        right: 0,
-        left: 0
+    if (this.pitching && !currently.pitching) {
+      this.emit('pitchstart', new Event('pitchstart', eventData));
+    }
+  }
+  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;
+    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 Event('zoomend', eventData));
+    }
+    if (wasRotating) {
+      this.emit('rotateend', new Event('rotateend', eventData));
+    }
+    if (wasPitching) {
+      this.emit('pitchend', new Event('pitchend', eventData));
+    }
+    this.emit('moveend', new Event('moveend', eventData));
+  }
+  ease(frame, finish, options) {
+    if (options.animate === false || options.duration === 0) {
+      frame(1);
+      finish();
+    } else {
+      this.easeStart = 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 = 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
       };
-      options = 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 = merge(defaultPadding, options.padding);
-      var tr = this.transform;
-      var edgePadding = tr.padding;
+    }
+    options.padding = merge(defaultPadding, options.padding);
+    const tr = this.transform;
+    const 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(LngLat.convert(p0));
-      var p1world = tr.project(LngLat.convert(p1));
-      var p0rotated = p0world.rotate(-bearing * Math.PI / 180);
-      var p1rotated = p1world.rotate(-bearing * Math.PI / 180);
-      var upperRight = new Point(Math.max(p0rotated.x, p1rotated.x), Math.max(p0rotated.y, p1rotated.y));
-      var lowerLeft = new Point(Math.min(p0rotated.x, p1rotated.x), Math.min(p0rotated.y, p1rotated.y));
+    // 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.
+    const p0world = tr.project(LngLat.convert(p0));
+    const p1world = tr.project(LngLat.convert(p1));
+    const p0rotated = p0world.rotate(-bearing * Math.PI / 180);
+    const p1rotated = p1world.rotate(-bearing * Math.PI / 180);
+    const upperRight = new Point(Math.max(p0rotated.x, p1rotated.x), Math.max(p0rotated.y, p1rotated.y));
+    const lowerLeft = new Point(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.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(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
-      };
+    // Calculate zoom: consider the original bbox and padding.
+    const size = upperRight.sub(lowerLeft);
+    const scaleX = (tr.width - (
+    // @ts-ignore
+    edgePadding.left +
+    // @ts-ignore
+    edgePadding.right +
+    // @ts-ignore
+    options.padding.left +
+    // @ts-ignore
+    options.padding.right)) / size.x;
+    const 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;
     }
-  }, {
-    key: "fitInternal",
-    value: function fitInternal(calculatedOptions, options, eventData) {
-      // cameraForBounds warns + returns undefined if unable to fit:
-      if (!calculatedOptions) {
-        return this;
-      }
-      options = 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);
+    const 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.
+    const offset = Point.convert(options.offset);
+    // @ts-ignore
+    const paddingOffsetX = (options.padding.left - options.padding.right) / 2;
+    // @ts-ignore
+    const paddingOffsetY = (options.padding.top - options.padding.bottom) / 2;
+    const offsetAtInitialZoom = new Point(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) {
+    // cameraForBounds warns + returns undefined if unable to fit:
+    if (!calculatedOptions) {
+      return this;
     }
-  }]);
-  return Camera;
-}(EventEmitter);
-export { Camera as default };
+    options = 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);
+  }
+}