@progress/kendo-charts 2.7.2-dev.202502101310 → 2.7.2-develop.1

package/dist/es/map/map.js

@@ -79,7 +79,7 @@ import MapService from './../services/map-service';
 
 import { CENTER_CHANGE, INIT, ZOOM_CHANGE } from './constants';
 
-var math = Math,
+let math = Math,
     min = math.min,
     pow = math.pow,
     Point = g.Point,
@@ -92,31 +92,21 @@ var math = Math,
     VELOCITY_MULTIPLIER = 5,
     DEFAULT_ZOOM_RATE = 1;
 
-var layersMap = {
+const layersMap = {
     bubble: BubbleLayer,
     shape: ShapeLayer,
-    tile: TileLayer
+    tile: TileLayer,
+    [MARKER]: MarkerLayer
 };
-layersMap[MARKER] = MarkerLayer;
 
-var Map = (function (Observable) {
-    function Map(element, options, themeOptions, context) {
-        if ( options === void 0 ) options = {};
-        if ( themeOptions === void 0 ) themeOptions = {};
-        if ( context === void 0 ) context = {};
-
-        Observable.call(this);
+class Map extends Observable {
+    constructor(element, options = {}, themeOptions = {}, context = {}) {
+        super();
 
         this._init(element, options, themeOptions, context);
     }
 
-    if ( Observable ) Map.__proto__ = Observable;
-    Map.prototype = Object.create( Observable && Observable.prototype );
-    Map.prototype.constructor = Map;
-
-    Map.prototype.destroy = function destroy () {
-        var this$1 = this;
-
+    destroy() {
         this.scroller.destroy();
 
         if (this._tooltip) {
@@ -134,28 +124,24 @@ var Map = (function (Observable) {
         }
 
         if (isArray(this.markers)) {
-            this.markers.forEach(function (markerLayer) {
+            this.markers.forEach(markerLayer => {
                 markerLayer.destroy();
             });
         } else {
             this.markers.destroy();
         }
 
-        for (var i = 0; i < this.layers.length; i++) {
-            this$1.layers[i].destroy();
+        for (let i = 0; i < this.layers.length; i++) {
+            this.layers[i].destroy();
         }
 
         off(this.element, MOUSEWHEEL, this._mousewheelHandler);
 
-        Observable.prototype.destroy.call(this);
-    };
+        super.destroy();
+    }
 
     // eslint-disable-next-line no-unused-vars
-    Map.prototype._init = function _init (element, options, themeOptions, context) {
-        if ( options === void 0 ) options = {};
-        if ( themeOptions === void 0 ) themeOptions = {};
-        if ( context === void 0 ) context = {};
-
+    _init(element, options = {}, themeOptions = {}, context = {}) {
         this.support = getSupportedFeatures();
         this.context = context;
 
@@ -178,19 +164,19 @@ var Map = (function (Observable) {
         this._initLayers();
         this._reset();
 
-        var mousewheelThrottled = throttle(this._mousewheel.bind(this), MOUSEWHEEL_THROTTLE);
-        this._mousewheelHandler = function (e) {
+        const mousewheelThrottled = throttle(this._mousewheel.bind(this), MOUSEWHEEL_THROTTLE);
+        this._mousewheelHandler = (e) => {
             e.preventDefault();
             mousewheelThrottled(e);
         };
         on(this.element, MOUSEWHEEL, this._mousewheelHandler);
-    };
+    }
 
-    Map.prototype._initOptions = function _initOptions (options) {
+    _initOptions(options) {
         this.options = deepExtend({}, this.options, options);
-    };
+    }
 
-    Map.prototype._initElement = function _initElement (element) {
+    _initElement(element) {
         this.element = element;
 
         addClass(element, "k-map");
@@ -198,91 +184,83 @@ var Map = (function (Observable) {
         element.setAttribute("data-role", "map");
         removeChildren(element);
 
-        var div = convertToHtml("<div />");
+        const div = convertToHtml("<div />");
         this.element.appendChild(div);
-    };
-
-    Map.prototype.initServices = function initServices (context) {
-        if ( context === void 0 ) context = {};
+    }
 
+    initServices(context = {}) {
         this.widgetService = new MapService(this, context);
-    };
-
-    Map.prototype.initObserver = function initObserver (context) {
-        if ( context === void 0 ) context = {};
+    }
 
+    initObserver(context = {}) {
         this.observers = [];
         this.addObserver(context.observer);
-    };
+    }
 
-    Map.prototype.addObserver = function addObserver (observer) {
+    addObserver(observer) {
         if (observer) {
             this.observers.push(observer);
         }
-    };
+    }
 
-    Map.prototype.removeObserver = function removeObserver (observer) {
-        var index = this.observers.indexOf(observer);
+    removeObserver(observer) {
+        const index = this.observers.indexOf(observer);
 
         if (index >= 0) {
             this.observers.splice(index, 1);
         }
-    };
+    }
 
-    Map.prototype.requiresHandlers = function requiresHandlers (eventNames) {
-        var observers = this.observers;
+    requiresHandlers(eventNames) {
+        const observers = this.observers;
 
-        for (var idx = 0; idx < observers.length; idx++) {
+        for (let idx = 0; idx < observers.length; idx++) {
             if (observers[idx].requiresHandlers(eventNames)) {
                 return true;
             }
         }
-    };
-
-    Map.prototype.trigger = function trigger (name, args) {
-        if ( args === void 0 ) args = {};
+    }
 
+    trigger(name, args = {}) {
         args.sender = this;
 
-        var observers = this.observers;
-        var isDefaultPrevented = false;
+        const observers = this.observers;
+        let isDefaultPrevented = false;
 
-        for (var idx = 0; idx < observers.length; idx++) {
+        for (let idx = 0; idx < observers.length; idx++) {
             if (observers[idx].trigger(name, args)) {
                 isDefaultPrevented = true;
             }
         }
 
         if (!isDefaultPrevented) {
-            Observable.prototype.trigger.call(this, name, args);
+            super.trigger(name, args);
         }
 
         return isDefaultPrevented;
-    };
-
-    Map.prototype._notifyObserver = function _notifyObserver (name, args) {
-        if ( args === void 0 ) args = {};
+    }
 
+    _notifyObserver(name, args = {}) {
         args.sender = this;
 
-        var observers = this.observers;
-        var isDefaultPrevented = false;
+        const observers = this.observers;
+        let isDefaultPrevented = false;
 
-        for (var idx = 0; idx < observers.length; idx++) {
+        for (let idx = 0; idx < observers.length; idx++) {
             if (observers[idx].trigger(name, args)) {
                 isDefaultPrevented = true;
             }
         }
 
         return isDefaultPrevented;
-    };
+    }
 
-    Map.prototype.zoom = function zoom (level) {
-        var options = this.options;
-        var result;
+    zoom(level) {
+        let options = this.options;
+        let result;
 
         if (defined(level)) {
-            var zoomLevel = math.round(limitValue(level, options.minZoom, options.maxZoom));
+            const zoomLevel = math.round(limitValue(level, options.minZoom, options.maxZoom));
 
             if (options.zoom !== zoomLevel) {
                 options.zoom = zoomLevel;
@@ -296,14 +274,14 @@ var Map = (function (Observable) {
         }
 
         return result;
-    };
+    }
 
-    Map.prototype.center = function center (center$1) {
-        var result;
+    center(center) {
+        let result;
 
-        if (center$1) {
-            var current = Location.create(center$1);
-            var previous = Location.create(this.options.center);
+        if (center) {
+            const current = Location.create(center);
+            const previous = Location.create(this.options.center);
             if (!current.equals(previous)) {
                 this.options.center = current.toArray();
                 this.widgetService.notify(CENTER_CHANGE, { center: this.options.center });
@@ -316,100 +294,98 @@ var Map = (function (Observable) {
         }
 
         return result;
-    };
+    }
 
-    Map.prototype.extent = function extent (extent$1) {
-        var result;
+    extent(extent) {
+        let result;
 
-        if (extent$1) {
-            this._setExtent(extent$1);
+        if (extent) {
+            this._setExtent(extent);
             result = this;
         } else {
             result = this._getExtent();
         }
 
         return result;
-    };
-
-    Map.prototype.setOptions = function setOptions (options) {
-        if ( options === void 0 ) options = {};
+    }
 
-        var element = this.element;
+    setOptions(options = {}) {
+        const element = this.element;
 
         this.destroy();
         removeChildren(element);
         this._init(element, options, {}, this.context);
 
         this._reset();
-    };
+    }
 
-    Map.prototype.locationToLayer = function locationToLayer (location, zoom) {
-        var clamp = !this.options.wraparound;
-        var locationObject = Location.create(location);
+    locationToLayer(location, zoom) {
+        let clamp = !this.options.wraparound;
+        const locationObject = Location.create(location);
 
         return this.crs.toPoint(locationObject, this._layerSize(zoom), clamp);
-    };
+    }
 
-    Map.prototype.layerToLocation = function layerToLocation (point, zoom) {
-        var clamp = !this.options.wraparound;
-        var pointObject = Point.create(point);
+    layerToLocation(point, zoom) {
+        let clamp = !this.options.wraparound;
+        const pointObject = Point.create(point);
 
         return this.crs.toLocation(pointObject, this._layerSize(zoom), clamp);
-    };
+    }
 
-    Map.prototype.locationToView = function locationToView (location) {
-        var locationObject = Location.create(location);
-        var origin = this.locationToLayer(this._viewOrigin);
-        var point = this.locationToLayer(locationObject);
+    locationToView(location) {
+        const locationObject = Location.create(location);
+        let origin = this.locationToLayer(this._viewOrigin);
+        let point = this.locationToLayer(locationObject);
 
         return point.translateWith(origin.scale(-1));
-    };
+    }
 
-    Map.prototype.viewToLocation = function viewToLocation (point, zoom) {
-        var origin = this.locationToLayer(this._getOrigin(), zoom);
-        var pointObject = Point.create(point);
-        var pointResult = pointObject.clone().translateWith(origin);
+    viewToLocation(point, zoom) {
+        const origin = this.locationToLayer(this._getOrigin(), zoom);
+        const pointObject = Point.create(point);
+        const pointResult = pointObject.clone().translateWith(origin);
 
         return this.layerToLocation(pointResult, zoom);
-    };
+    }
 
-    Map.prototype.eventOffset = function eventOffset (e) {
-        var x;
-        var y;
-        var offset = elementOffset(this.element);
+    eventOffset(e) {
+        let x;
+        let y;
+        let offset = elementOffset(this.element);
 
         if ((e.x && e.x[LOCATION]) || (e.y && e.y[LOCATION])) {
             x = e.x[LOCATION] - offset.left;
             y = e.y[LOCATION] - offset.top;
         } else {
-            var event = e.originalEvent || e;
+            let event = e.originalEvent || e;
             x = valueOrDefault(event.pageX, event.clientX) - offset.left;
             y = valueOrDefault(event.pageY, event.clientY) - offset.top;
         }
 
-        var point = new g.Point(x, y);
+        const point = new g.Point(x, y);
 
         return point;
-    };
+    }
 
-    Map.prototype.eventToView = function eventToView (e) {
-        var cursor = this.eventOffset(e);
+    eventToView(e) {
+        let cursor = this.eventOffset(e);
         return this.locationToView(this.viewToLocation(cursor));
-    };
+    }
 
-    Map.prototype.eventToLayer = function eventToLayer (e) {
+    eventToLayer(e) {
         return this.locationToLayer(this.eventToLocation(e));
-    };
+    }
 
-    Map.prototype.eventToLocation = function eventToLocation (e) {
-        var cursor = this.eventOffset(e);
+    eventToLocation(e) {
+        let cursor = this.eventOffset(e);
         return this.viewToLocation(cursor);
-    };
+    }
 
-    Map.prototype.viewSize = function viewSize () {
-        var element = this.element;
-        var scale = this._layerSize();
-        var width = element.clientWidth;
+    viewSize() {
+        let element = this.element;
+        let scale = this._layerSize();
+        let width = element.clientWidth;
 
         if (!this.options.wraparound) {
             width = min(scale, width);
@@ -419,24 +395,24 @@ var Map = (function (Observable) {
             width: width,
             height: min(scale, element.clientHeight)
         };
-    };
+    }
 
-    Map.prototype.exportVisual = function exportVisual () {
+    exportVisual() {
         this._reset();
         return false;
-    };
+    }
 
-    Map.prototype.hideTooltip = function hideTooltip () {
+    hideTooltip() {
         if (this._tooltip) {
             this._tooltip.hide();
         }
-    };
+    }
 
-    Map.prototype._setOrigin = function _setOrigin (origin, zoom) {
-        var size = this.viewSize(),
+    _setOrigin(origin, zoom) {
+        let size = this.viewSize(),
             topLeft;
 
-        var originLocation = this._origin = Location.create(origin);
+        const originLocation = this._origin = Location.create(origin);
         topLeft = this.locationToLayer(originLocation, zoom);
         topLeft.x += size.width / 2;
         topLeft.y += size.height / 2;
@@ -444,10 +420,10 @@ var Map = (function (Observable) {
         this.widgetService.notify(CENTER_CHANGE, { center: this.options.center });
 
         return this;
-    };
+    }
 
-    Map.prototype._getOrigin = function _getOrigin (invalidate) {
-        var size = this.viewSize(),
+    _getOrigin(invalidate) {
+        let size = this.viewSize(),
             topLeft;
 
         if (invalidate || !this._origin) {
@@ -458,29 +434,27 @@ var Map = (function (Observable) {
         }
 
         return this._origin;
-    };
-
-    Map.prototype._setExtent = function _setExtent (newExtent) {
-        var this$1 = this;
+    }
 
-        var raw = Extent.create(newExtent);
-        var se = raw.se.clone();
+    _setExtent(newExtent) {
+        let raw = Extent.create(newExtent);
+        let se = raw.se.clone();
 
         if (this.options.wraparound && se.lng < 0 && newExtent.nw.lng > 0) {
             se.lng = 180 + (180 + se.lng);
         }
 
-        var extent = new Extent(raw.nw, se);
+        const extent = new Extent(raw.nw, se);
         this.center(extent.center());
-        var width = this.element.clientWidth;
-        var height = this.element.clientHeight;
-        var zoom;
+        let width = this.element.clientWidth;
+        let height = this.element.clientHeight;
+        let zoom;
 
         for (zoom = this.options.maxZoom; zoom >= this.options.minZoom; zoom--) {
-            var topLeft = this$1.locationToLayer(extent.nw, zoom);
-            var bottomRight = this$1.locationToLayer(extent.se, zoom);
-            var layerWidth = math.abs(bottomRight.x - topLeft.x);
-            var layerHeight = math.abs(bottomRight.y - topLeft.y);
+            let topLeft = this.locationToLayer(extent.nw, zoom);
+            let bottomRight = this.locationToLayer(extent.se, zoom);
+            let layerWidth = math.abs(bottomRight.x - topLeft.x);
+            let layerHeight = math.abs(bottomRight.y - topLeft.y);
 
             if (layerWidth <= width && layerHeight <= height) {
                 break;
@@ -488,28 +462,28 @@ var Map = (function (Observable) {
         }
 
         this.zoom(zoom);
-    };
+    }
 
-    Map.prototype._getExtent = function _getExtent () {
-        var nw = this._getOrigin();
-        var bottomRight = this.locationToLayer(nw);
-        var size = this.viewSize();
+    _getExtent() {
+        let nw = this._getOrigin();
+        let bottomRight = this.locationToLayer(nw);
+        let size = this.viewSize();
 
         bottomRight.x += size.width;
         bottomRight.y += size.height;
 
-        var se = this.layerToLocation(bottomRight);
+        let se = this.layerToLocation(bottomRight);
 
         return new Extent(nw, se);
-    };
+    }
 
-    Map.prototype._zoomAround = function _zoomAround (pivot, level) {
+    _zoomAround(pivot, level) {
         this._setOrigin(this.layerToLocation(pivot, level), level);
         this.zoom(level);
-    };
+    }
 
-    Map.prototype._initControls = function _initControls () {
-        var controls = this.options.controls;
+    _initControls() {
+        let controls = this.options.controls;
         if (controls.attribution) {
             this._createAttribution(controls.attribution);
         }
@@ -523,50 +497,50 @@ var Map = (function (Observable) {
                 this._createZoomControl(controls.zoom);
             }
         }
-    };
+    }
 
-    Map.prototype._createControlElement = function _createControlElement (options, defaultPosition) {
-        var pos = options.position || defaultPosition;
-        var posSelector = '.' + renderPos(pos).replace(' ', '.');
-        var wrap = this.element.querySelector('.k-map-controls' + posSelector) || [];
+    _createControlElement(options, defaultPosition) {
+        let pos = options.position || defaultPosition;
+        let posSelector = '.' + renderPos(pos).replace(' ', '.');
+        let wrap = this.element.querySelector('.k-map-controls' + posSelector) || [];
 
         if (wrap.length === 0) {
-            var div$1 = document.createElement("div");
-            addClass(div$1, 'k-map-controls ' + renderPos(pos));
-            wrap = div$1;
+            let div = document.createElement("div");
+            addClass(div, 'k-map-controls ' + renderPos(pos));
+            wrap = div;
             this.element.appendChild(wrap);
         }
 
-        var div = document.createElement("div");
+        let div = document.createElement("div");
 
         wrap.appendChild(div);
 
         return div;
-    };
+    }
 
-    Map.prototype._createAttribution = function _createAttribution (options) {
-        var element = this._createControlElement(options, 'bottomRight');
+    _createAttribution(options) {
+        let element = this._createControlElement(options, 'bottomRight');
         this.attribution = new Attribution(element, options);
-    };
+    }
 
-    Map.prototype._createNavigator = function _createNavigator (options) {
-        var element = this._createControlElement(options, 'topLeft');
-        var navigator = this.navigator = new Navigator(element, deepExtend({}, options, { icons: this.options.icons }));
+    _createNavigator(options) {
+        let element = this._createControlElement(options, 'topLeft');
+        let navigator = this.navigator = new Navigator(element, deepExtend({}, options, { icons: this.options.icons }));
 
         this._navigatorPan = this._navigatorPan.bind(this);
         navigator.bind('pan', this._navigatorPan);
 
         this._navigatorCenter = this._navigatorCenter.bind(this);
         navigator.bind('center', this._navigatorCenter);
-    };
+    }
 
-    Map.prototype._navigatorPan = function _navigatorPan (e) {
-        var scroller = this.scroller;
-        var x = scroller.scrollLeft + e.x;
-        var y = scroller.scrollTop - e.y;
-        var bounds = this._virtualSize;
-        var width = this.element.clientWidth;
-        var height = this.element.clientHeight;
+    _navigatorPan(e) {
+        let scroller = this.scroller;
+        let x = scroller.scrollLeft + e.x;
+        let y = scroller.scrollTop - e.y;
+        let bounds = this._virtualSize;
+        let width = this.element.clientWidth;
+        let height = this.element.clientHeight;
 
         // TODO: Move limits to scroller
         x = limitValue(x, bounds.x.min, bounds.x.max - width);
@@ -575,21 +549,21 @@ var Map = (function (Observable) {
         this.scroller.one('scroll', proxy(this._scrollEnd, this));
 
         this.scroller.scrollTo(-x, -y);
-    };
+    }
 
-    Map.prototype._navigatorCenter = function _navigatorCenter () {
+    _navigatorCenter() {
         this.center(this.options.center);
-    };
+    }
 
-    Map.prototype._createZoomControl = function _createZoomControl (options) {
-        var element = this._createControlElement(options, 'topLeft');
-        var zoomControl = this.zoomControl = new ZoomControl(element, options, this.options.icons);
+    _createZoomControl(options) {
+        let element = this._createControlElement(options, 'topLeft');
+        let zoomControl = this.zoomControl = new ZoomControl(element, options, this.options.icons);
 
         this._zoomControlChange = this._zoomControlChange.bind(this);
         zoomControl.bind('change', this._zoomControlChange);
-    };
+    }
 
-    Map.prototype._zoomControlChange = function _zoomControlChange (e) {
+    _zoomControlChange(e) {
         if (!this.trigger('zoomStart', { originalEvent: e })) {
             this.zoom(this.zoom() + e.delta);
 
@@ -597,12 +571,12 @@ var Map = (function (Observable) {
                 originalEvent: e
             });
         }
-    };
+    }
 
-    Map.prototype._initScroller = function _initScroller () {
-        var friction = this.support.mobileOS ? FRICTION_MOBILE : FRICTION;
-        var zoomable = this.options.zoomable !== false;
-        var scroller = this.scroller = new Scroller(this.element.children[0], {
+    _initScroller() {
+        let friction = this.support.mobileOS ? FRICTION_MOBILE : FRICTION;
+        let zoomable = this.options.zoomable !== false;
+        let scroller = this.scroller = new Scroller(this.element.children[0], {
             friction: friction,
             velocityMultiplier: VELOCITY_MULTIPLIER,
             zoom: zoomable,
@@ -619,46 +593,44 @@ var Map = (function (Observable) {
         scroller.userEvents.bind('tap', proxy(this._tap, this));
 
         this.scrollElement = scroller.scrollElement;
-    };
-
-    Map.prototype._initLayers = function _initLayers () {
-        var this$1 = this;
+    }
 
-        var defs = this.options.layers,
+    _initLayers() {
+        let defs = this.options.layers,
             layers = this.layers = [];
 
-        for (var i = 0; i < defs.length; i++) {
-            var options = defs[i];
+        for (let i = 0; i < defs.length; i++) {
+            let options = defs[i];
 
-            var layer = this$1._createLayer(options);
+            const layer = this._createLayer(options);
             layers.push(layer);
         }
-    };
+    }
 
-    Map.prototype._createLayer = function _createLayer (options) {
-        var type = options.type || 'shape';
-        var layerDefaults = this.options.layerDefaults[type];
-        var layerOptions = type === MARKER ?
+    _createLayer(options) {
+        let type = options.type || 'shape';
+        let layerDefaults = this.options.layerDefaults[type];
+        let layerOptions = type === MARKER ?
             deepExtend({}, this.options.markerDefaults, options, { icons: this.options.icons }) :
             deepExtend({}, layerDefaults, options);
 
-        var layerConstructor = layersMap[type];
-        var layer = new layerConstructor(this, layerOptions);
+        let layerConstructor = layersMap[type];
+        let layer = new layerConstructor(this, layerOptions);
 
         if (type === MARKER) {
             this.markers = layer;
         }
 
         return layer;
-    };
+    }
 
-    Map.prototype._createTooltip = function _createTooltip () {
+    _createTooltip() {
         return new Tooltip(this.widgetService, this.options.tooltip);
-    };
+    }
 
     /* eslint-disable arrow-body-style */
-    Map.prototype._initMarkers = function _initMarkers () {
-        var markerLayers = (this.options.layers || []).filter(function (x) {
+    _initMarkers() {
+        const markerLayers = (this.options.layers || []).filter(x => {
             return x && x.type === MARKER;
         });
 
@@ -670,13 +642,13 @@ var Map = (function (Observable) {
 
         this.markers = new MarkerLayer(this, deepExtend({}, this.options.markerDefaults, { icons: this.options.icons }));
         this.markers.add(this.options.markers);
-    };
+    }
     /* eslint-enable arrow-body-style */
 
-    Map.prototype._scroll = function _scroll (e) {
-        var origin = this.locationToLayer(this._viewOrigin).round();
-        var movable = e.sender.movable;
-        var offset = new g.Point(movable.x, movable.y).scale(-1).scale(1 / movable.scale);
+    _scroll(e) {
+        let origin = this.locationToLayer(this._viewOrigin).round();
+        let movable = e.sender.movable;
+        let offset = new g.Point(movable.x, movable.y).scale(-1).scale(1 / movable.scale);
 
         origin.x += offset.x;
         origin.y += offset.y;
@@ -692,9 +664,9 @@ var Map = (function (Observable) {
             origin: this._getOrigin(),
             center: this.center()
         });
-    };
+    }
 
-    Map.prototype._scrollEnd = function _scrollEnd (e) {
+    _scrollEnd(e) {
         if (!this._scrollOffset || !this._panComplete()) {
             return;
         }
@@ -707,46 +679,46 @@ var Map = (function (Observable) {
             origin: this._getOrigin(),
             center: this.center()
         });
-    };
+    }
 
-    Map.prototype._panComplete = function _panComplete () {
+    _panComplete() {
         return now() - (this._panEndTimestamp || 0) > 50;
-    };
+    }
 
-    Map.prototype._scaleStart = function _scaleStart (e) {
+    _scaleStart(e) {
         if (this.trigger('zoomStart', { originalEvent: e })) {
-            var touch = e.touches[1];
+            let touch = e.touches[1];
 
             if (touch) {
                 touch.cancel();
             }
         }
-    };
+    }
 
-    Map.prototype._scale = function _scale (e) {
-        var scale = this.scroller.movable.scale;
-        var zoom = this._scaleToZoom(scale);
-        var gestureCenter = new g.Point(e.center.x, e.center.y);
-        var centerLocation = this.viewToLocation(gestureCenter, zoom);
-        var centerPoint = this.locationToLayer(centerLocation, zoom);
-        var originPoint = centerPoint.translate(-gestureCenter.x, -gestureCenter.y);
+    _scale(e) {
+        let scale = this.scroller.movable.scale;
+        let zoom = this._scaleToZoom(scale);
+        let gestureCenter = new g.Point(e.center.x, e.center.y);
+        let centerLocation = this.viewToLocation(gestureCenter, zoom);
+        let centerPoint = this.locationToLayer(centerLocation, zoom);
+        let originPoint = centerPoint.translate(-gestureCenter.x, -gestureCenter.y);
 
         this._zoomAround(originPoint, zoom);
 
         this.trigger('zoomEnd', {
             originalEvent: e
         });
-    };
+    }
 
-    Map.prototype._scaleToZoom = function _scaleToZoom (scaleDelta) {
-        var scale = this._layerSize() * scaleDelta;
-        var tiles = scale / this.options.minSize;
-        var zoom = math.log(tiles) / math.log(2);
+    _scaleToZoom(scaleDelta) {
+        let scale = this._layerSize() * scaleDelta;
+        let tiles = scale / this.options.minSize;
+        let zoom = math.log(tiles) / math.log(2);
 
         return math.round(zoom);
-    };
+    }
 
-    Map.prototype._reset = function _reset () {
+    _reset() {
         if (this.attribution) {
             this.attribution.filter(this.center(), this.zoom());
         }
@@ -758,31 +730,31 @@ var Map = (function (Observable) {
 
         this.trigger('beforeReset');
         this.trigger('reset');
-    };
+    }
 
-    Map.prototype._resetScroller = function _resetScroller () {
-        var scroller = this.scroller;
-        var x = scroller.dimensions.x;
-        var y = scroller.dimensions.y;
-        var scale = this._layerSize();
-        var nw = this.extent().nw;
-        var topLeft = this.locationToLayer(nw).round();
+    _resetScroller() {
+        let scroller = this.scroller;
+        let x = scroller.dimensions.x;
+        let y = scroller.dimensions.y;
+        let scale = this._layerSize();
+        let nw = this.extent().nw;
+        let topLeft = this.locationToLayer(nw).round();
 
         scroller.movable.round = true;
         scroller.reset();
         scroller.userEvents.cancel();
 
-        var zoom = this.zoom();
+        let zoom = this.zoom();
 
         scroller.dimensions.forcedMinScale = pow(2, this.options.minZoom - zoom);
         scroller.dimensions.maxScale = pow(2, this.options.maxZoom - zoom);
 
-        var xBounds = {
+        let xBounds = {
             min: -topLeft.x,
             max: scale - topLeft.x
         };
 
-        var yBounds = {
+        let yBounds = {
             min: -topLeft.y,
             max: scale - topLeft.y
         };
@@ -793,7 +765,7 @@ var Map = (function (Observable) {
         }
 
         if (this.options.pannable === false) {
-            var viewSize = this.viewSize();
+            let viewSize = this.viewSize();
             xBounds.min = yBounds.min = 0;
             xBounds.max = viewSize.width;
             yBounds.max = viewSize.height;
@@ -809,41 +781,41 @@ var Map = (function (Observable) {
             x: xBounds,
             y: yBounds
         };
-    };
+    }
 
     // kept for API compatibility, not used
-    Map.prototype._renderLayers = function _renderLayers () {
-    };
+    _renderLayers() {
+    }
 
-    Map.prototype._layerSize = function _layerSize (zoom) {
-        var newZoom = valueOrDefault(zoom, this.options.zoom);
+    _layerSize(zoom) {
+        const newZoom = valueOrDefault(zoom, this.options.zoom);
         return this.options.minSize * pow(2, newZoom);
-    };
+    }
 
-    Map.prototype._tap = function _tap (e) {
+    _tap(e) {
         if (!this._panComplete()) {
             return;
         }
 
-        var cursor = this.eventOffset(e);
+        let cursor = this.eventOffset(e);
         this.hideTooltip();
 
         this.trigger('click', {
             originalEvent: e,
             location: this.viewToLocation(cursor)
         });
-    };
+    }
 
-    Map.prototype._doubleTap = function _doubleTap (e) {
-        var options = this.options;
+    _doubleTap(e) {
+        let options = this.options;
 
         if (options.zoomable !== false) {
             if (!this.trigger('zoomStart', { originalEvent: e })) {
-                var toZoom = this.zoom() + DEFAULT_ZOOM_RATE;
-                var cursor = this.eventOffset(e);
-                var location = this.viewToLocation(cursor);
-                var postZoom = this.locationToLayer(location, toZoom);
-                var origin = postZoom.translate(-cursor.x, -cursor.y);
+                let toZoom = this.zoom() + DEFAULT_ZOOM_RATE;
+                let cursor = this.eventOffset(e);
+                let location = this.viewToLocation(cursor);
+                let postZoom = this.locationToLayer(location, toZoom);
+                let origin = postZoom.translate(-cursor.x, -cursor.y);
 
                 this._zoomAround(origin, toZoom);
 
@@ -852,20 +824,20 @@ var Map = (function (Observable) {
                 });
             }
         }
-    };
+    }
 
-    Map.prototype._mousewheel = function _mousewheel (e) {
-        var delta = mousewheelDelta(e) > 0 ? -1 : 1;
-        var options = this.options;
-        var fromZoom = this.zoom();
-        var toZoom = limitValue(fromZoom + delta, options.minZoom, options.maxZoom);
+    _mousewheel(e) {
+        let delta = mousewheelDelta(e) > 0 ? -1 : 1;
+        let options = this.options;
+        let fromZoom = this.zoom();
+        let toZoom = limitValue(fromZoom + delta, options.minZoom, options.maxZoom);
 
         if (options.zoomable !== false && toZoom !== fromZoom) {
             if (!this.trigger('zoomStart', { originalEvent: e })) {
-                var cursor = this.eventOffset(e);
-                var location = this.viewToLocation(cursor);
-                var postZoom = this.locationToLayer(location, toZoom);
-                var origin = postZoom.translate(-cursor.x, -cursor.y);
+                let cursor = this.eventOffset(e);
+                let location = this.viewToLocation(cursor);
+                let postZoom = this.locationToLayer(location, toZoom);
+                let origin = postZoom.translate(-cursor.x, -cursor.y);
 
                 this._zoomAround(origin, toZoom);
 
@@ -874,19 +846,17 @@ var Map = (function (Observable) {
                 });
             }
         }
-    };
+    }
 
-    Map.prototype._toDocumentCoordinates = function _toDocumentCoordinates (point) {
-        var offset = elementOffset(this.element);
+    _toDocumentCoordinates(point) {
+        const offset = elementOffset(this.element);
 
         return {
             left: round(point.x + offset.left),
             top: round(point.y + offset.top)
         };
-    };
-
-    return Map;
-}(Observable));
+    }
+}
 
 setDefaultOptions(Map, {
     name: 'Map',