@nextgis/leaflet-map-adapter 1.11.0 → 1.12.0

package/lib/leaflet-map-adapter.esm-bundler.js

@@ -1,26 +1,129 @@
-/** Bundle of @nextgis/leaflet-map-adapter; version: 1.11.0; author: NextGIS */
+/** Bundle of @nextgis/leaflet-map-adapter; version: 1.12.0; author: NextGIS */
 import { EventEmitter } from 'events';
-import { Control, DomEvent, GeoJSON, FeatureGroup, DivIcon, Marker, CircleMarker, ImageOverlay as ImageOverlay$1, Layer, Util, CRS, GridLayer, DomUtil, TileLayer as TileLayer$1, Map } from 'leaflet';
-import { debounce as debounce$1, defined } from '@nextgis/utils';
+import { Control, DomEvent, GeoJSON, FeatureGroup, DivIcon, Marker, CircleMarker, ImageOverlay as ImageOverlay$1, Util, CRS, Layer, GridLayer, DomUtil, TileLayer as TileLayer$1, Map } from 'leaflet';
+import { defined, debounce as debounce$1 } from '@nextgis/utils';
 import { isPaintCallback, isPaint } from '@nextgis/paint';
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
 function convertMapClickEvent(evt) {
-    const coord = evt.containerPoint;
-    const latLng = evt.latlng;
-    const { lat, lng } = latLng;
+    var coord = evt.containerPoint;
+    var latLng = evt.latlng;
+    var lat = latLng.lat, lng = latLng.lng;
     return {
-        latLng,
+        latLng: latLng,
         lngLat: [lng, lat],
         pixel: { left: coord.x, top: coord.y },
         source: evt,
     };
 }
 
-function createControl(control, options = {}, map) {
-    const C = Control.extend({
-        onAdd() {
-            const element = document.createElement('div');
-            const content = control.onAdd(map);
+function createControl(control, options, map) {
+    if (options === void 0) { options = {}; }
+    var C = Control.extend({
+        onAdd: function () {
+            var element = document.createElement('div');
+            var content = control.onAdd(map);
             element.classList.add('leaflet-control');
             if (options.bar) {
                 element.classList.add('leaflet-bar');
@@ -40,7 +143,7 @@ function createControl(control, options = {}, map) {
             DomEvent.disableClickPropagation(element);
             return element;
         },
-        onRemove() {
+        onRemove: function () {
             control.onRemove();
         },
     });
@@ -48,12 +151,15 @@ function createControl(control, options = {}, map) {
 }
 
 function createButtonControl(options, map) {
-    const link = document.createElement('a');
-    const title = options.title || '';
+    var link = document.createElement('a');
+    var title = options.title || '';
     link.href = '#';
     link.title = title;
     link.setAttribute('role', 'button');
     link.setAttribute('aria-label', title);
+    if (options.addClass) {
+        link.classList.add(options.addClass);
+    }
     DomEvent.disableClickPropagation(link);
     DomEvent.on(link, 'click', DomEvent.stop);
     if (options.html instanceof HTMLElement) {
@@ -62,19 +168,19 @@ function createButtonControl(options, map) {
     else if (typeof options.html === 'string') {
         link.innerHTML = options.html;
     }
-    const onClick = (e) => {
+    var onClick = function (e) {
         e.stopPropagation();
         options.onClick();
     };
     return createControl({
-        onAdd() {
+        onAdd: function () {
             if (options.onClick !== undefined) {
                 link.addEventListener('click', onClick);
             }
             return link;
         },
-        onRemove() {
-            const parent = link.parentNode;
+        onRemove: function () {
+            var parent = link.parentNode;
             if (parent) {
                 parent.removeChild(link);
             }
@@ -85,31 +191,34 @@ function createButtonControl(options, map) {
     }, { bar: true }, map);
 }
 
-class AttributionControl extends Control.Attribution {
+var AttributionControl = /** @class */ (function (_super) {
+    __extends(AttributionControl, _super);
     // options: AttributionControlOptions
-    constructor(options) {
-        super(options);
-        const customAttribution = options && options.customAttribution;
+    function AttributionControl(options) {
+        var _this = _super.call(this, options) || this;
+        var customAttribution = options && options.customAttribution;
         if (customAttribution) {
-            let attributions = [];
+            var attributions = [];
             if (Array.isArray(customAttribution)) {
                 attributions = customAttribution;
             }
             else if (customAttribution) {
                 attributions = [customAttribution];
             }
-            attributions.forEach((x) => this.addAttribution(x));
+            attributions.forEach(function (x) { return _this.addAttribution(x); });
         }
+        return _this;
     }
-}
+    return AttributionControl;
+}(Control.Attribution));
 
 function boundsToArray(bounds) {
-    const ne = bounds.getNorthEast();
-    const sw = bounds.getSouthWest();
+    var ne = bounds.getNorthEast();
+    var sw = bounds.getSouthWest();
     return [sw.lng, sw.lat, ne.lng, ne.lat];
 }
 
-const typeAlias = {
+var typeAlias = {
     Point: 'point',
     LineString: 'line',
     MultiPoint: 'point',
@@ -118,79 +227,78 @@ const typeAlias = {
     MultiPolygon: 'polygon',
     GeometryCollection: 'polygon',
 };
-const PAINT = {
+var PAINT = {
     stroke: false,
     opacity: 1,
 };
-const backAliases = {};
-for (const a in typeAlias) {
-    const layerType = typeAlias[a];
-    const backAlias = backAliases[layerType] || [];
+var backAliases = {};
+for (var a in typeAlias) {
+    var layerType = typeAlias[a];
+    var backAlias = backAliases[layerType] || [];
     backAlias.push(a);
     backAliases[layerType] = backAlias;
 }
 function geometryFilter(geometry, type) {
-    const geoJsonGeometry = backAliases[type] || [];
+    var geoJsonGeometry = backAliases[type] || [];
     return geoJsonGeometry.indexOf(geometry) !== -1;
 }
 function filterGeometries(data, type) {
     if (data.type === 'FeatureCollection') {
-        const _data = data;
-        _data.features = _data.features.filter((f) => geometryFilter(f.geometry.type, type));
+        var _data = data;
+        _data.features = _data.features.filter(function (f) {
+            return geometryFilter(f.geometry.type, type);
+        });
     }
     else if (data.type === 'Feature') {
-        const allow = geometryFilter(data.geometry.type, type);
+        var allow = geometryFilter(data.geometry.type, type);
         if (!allow) {
             return false;
         }
     }
     else if (data.type === 'GeometryCollection') {
-        const _data = data;
-        _data.geometries = _data.geometries.filter((g) => geometryFilter(g.type, type));
+        var _data = data;
+        _data.geometries = _data.geometries.filter(function (g) {
+            return geometryFilter(g.type, type);
+        });
     }
     return data;
 }
 function featuresBounds(features) {
-    const geoJsonLayer = new GeoJSON();
-    const features_ = Array.isArray(features) ? features : [features];
-    features_.forEach((f) => geoJsonLayer.addData(f));
+    var geoJsonLayer = new GeoJSON();
+    var features_ = Array.isArray(features) ? features : [features];
+    features_.forEach(function (f) { return geoJsonLayer.addData(f); });
     return geoJsonLayer.getBounds();
 }
 function getFeaturesBounds(features) {
     return boundsToArray(featuresBounds(features));
 }
 function getFeaturesCenter(features) {
-    const { lat, lng } = featuresBounds(features).getCenter();
+    var _a = featuresBounds(features).getCenter(), lat = _a.lat, lng = _a.lng;
     return [lng, lat];
 }
 function createFeaturePositionOptions(features) {
     return {
-        getBounds: () => getFeaturesBounds(features),
-        getCenter: () => getFeaturesCenter(features),
+        getBounds: function () { return getFeaturesBounds(features); },
+        getCenter: function () { return getFeaturesCenter(features); },
     };
 }
 
-function createMouseEvent({ layer, source, }) {
-    const layer_ = source.target;
-    const feature = layer_.feature;
-    const opt = {
-        layer,
-        feature,
-        event: convertMapClickEvent(source),
-        source,
-        ...createFeaturePositionOptions(feature),
-    };
+function createMouseEvent(_a) {
+    var layer = _a.layer, source = _a.source;
+    var layer_ = source.target;
+    var feature = layer_.feature;
+    var opt = __assign({ layer: layer, feature: feature, event: convertMapClickEvent(source), source: source }, createFeaturePositionOptions(feature));
     return opt;
 }
 
 function findMostFrequentGeomType(arr) {
-    const counts = {};
-    for (let fry = 0; fry < arr.length; fry++) {
+    var counts = {};
+    for (var fry = 0; fry < arr.length; fry++) {
         counts[arr[fry]] = 1 + (counts[arr[fry]] || 0);
     }
-    let maxName = '';
-    for (const c in counts) {
-        const maxCount = maxName ? counts[maxName] : 0;
+    var maxName = '';
+    for (var c in counts) {
+        var maxCount = maxName ? counts[maxName] : 0;
         if (counts[c] > maxCount) {
             maxName = c;
         }
@@ -198,13 +306,13 @@ function findMostFrequentGeomType(arr) {
     return maxName;
 }
 function detectType(geojson) {
-    let geometry;
+    var geometry;
     if (geojson.type === 'FeatureCollection') {
-        const featuresTypes = geojson.features.map((f) => f.geometry.type);
+        var featuresTypes = geojson.features.map(function (f) { return f.geometry.type; });
         geometry = findMostFrequentGeomType(featuresTypes);
     }
     else if (geojson.type === 'GeometryCollection') {
-        const geometryTypes = geojson.geometries.map((g) => g.type);
+        var geometryTypes = geojson.geometries.map(function (g) { return g.type; });
         geometry = findMostFrequentGeomType(geometryTypes);
     }
     else if (geojson.type === 'Feature') {
@@ -216,14 +324,14 @@ function detectType(geojson) {
     return geometry;
 }
 
-class BaseAdapter {
-    constructor(map, options) {
+var BaseAdapter = /** @class */ (function () {
+    function BaseAdapter(map, options) {
         this.map = map;
         this.options = options;
         this.pane = 'order-0';
         if (options.order !== undefined) {
-            const pane = 'order-' + options.order;
-            let exist = map.getPane(pane);
+            var pane = 'order-' + options.order;
+            var exist = map.getPane(pane);
             if (!exist) {
                 exist = map.createPane(pane);
             }
@@ -231,34 +339,34 @@ class BaseAdapter {
             this.pane = pane;
         }
     }
-    addLayer(options) {
+    BaseAdapter.prototype.addLayer = function (options) {
         Object.assign(this.options, options);
         return undefined;
-    }
-}
+    };
+    return BaseAdapter;
+}());
 
-class GeoJsonAdapter extends BaseAdapter {
-    constructor(map, options) {
-        super(map, options);
-        this.selected = false;
-        this._layers = [];
-        this._selectedLayers = [];
-        this._filteredLayers = [];
-        this._openedPopup = [];
-        this.$updateTooltip = debounce$1(() => {
-            this.updateTooltip();
+var GeoJsonAdapter = /** @class */ (function (_super) {
+    __extends(GeoJsonAdapter, _super);
+    function GeoJsonAdapter(map, options) {
+        var _this = _super.call(this, map, options) || this;
+        _this.selected = false;
+        _this._layers = [];
+        _this._selectedLayers = [];
+        _this._filteredLayers = [];
+        _this._openedPopup = [];
+        _this.$updateTooltip = debounce$1(function () {
+            _this.updateTooltip();
         }, 300);
-        this.$unselect = () => {
-            this.unselect();
+        _this.$unselect = function () {
+            _this.unselect();
         };
+        return _this;
     }
-    addLayer(options) {
+    GeoJsonAdapter.prototype.addLayer = function (options) {
         Object.assign(this.options, options);
         this.paint = options.paint;
-        this.layer = new FeatureGroup([], {
-            ...options.nativeOptions,
-            pane: this.pane,
-        });
+        this.layer = new FeatureGroup([], __assign(__assign({}, options.nativeOptions), { pane: this.pane }));
         this.selectedPaint = options.selectedPaint;
         options.paint = this.paint;
         if (options.data) {
@@ -266,15 +374,16 @@ class GeoJsonAdapter extends BaseAdapter {
         }
         this._addMapListener();
         return this.layer;
-    }
-    beforeRemove() {
+    };
+    GeoJsonAdapter.prototype.beforeRemove = function () {
         this._removeMapListener();
-    }
-    select(findFeatureFun) {
+    };
+    GeoJsonAdapter.prototype.select = function (findFeatureFun) {
+        var _this = this;
         if (findFeatureFun) {
-            const def = this._layers.filter(findFeatureFun);
-            def.forEach((x) => {
-                this._selectLayer(x, 'api');
+            var def = this._layers.filter(findFeatureFun);
+            def.forEach(function (x) {
+                _this._selectLayer(x, 'api');
             });
         }
         else if (!this.selected) {
@@ -283,16 +392,18 @@ class GeoJsonAdapter extends BaseAdapter {
                 this._setPaintEachLayer(this.selectedPaint);
             }
         }
-    }
-    unselect(findFeatureFun) {
+    };
+    GeoJsonAdapter.prototype.unselect = function (findFeatureFun) {
+        var _this = this;
         if (findFeatureFun) {
-            const feature = this._layers.filter(findFeatureFun);
-            feature.forEach((x) => {
-                this._unSelectLayer(x);
+            var feature = this._layers.filter(findFeatureFun);
+            feature.forEach(function (x) {
+                _this._unSelectLayer(x);
             });
         }
         else if (this.selected) {
-            for (const p of this._openedPopup) {
+            for (var _i = 0, _a = this._openedPopup; _i < _a.length; _i++) {
+                var p = _a[_i];
                 this._removePopup(p[0]);
             }
             if (this.paint) {
@@ -301,83 +412,67 @@ class GeoJsonAdapter extends BaseAdapter {
             this._selectedLayers.length = 0;
             this.selected = false;
         }
-    }
-    getSelected() {
-        return this._selectedLayers.map((x) => {
-            return {
-                target: this,
-                feature: x.feature,
-                layer: x,
-                ...createFeaturePositionOptions(x.feature),
-            };
+    };
+    GeoJsonAdapter.prototype.getSelected = function () {
+        var _this = this;
+        return this._selectedLayers.map(function (x) {
+            return __assign({ target: _this, feature: x.feature, layer: x }, createFeaturePositionOptions(x.feature));
         });
-    }
-    getFiltered() {
+    };
+    GeoJsonAdapter.prototype.getFiltered = function () {
         return this._filteredLayers;
-    }
-    filter(fun) {
+    };
+    GeoJsonAdapter.prototype.filter = function (fun) {
+        var _this = this;
         // Some optimization
         this._filterFun = fun;
-        const layer_ = this.layer;
-        const map = layer_ && layer_._map;
+        var layer_ = this.layer;
+        var map = layer_ && layer_._map;
         if (layer_ && map) {
             layer_.remove();
-            const filteredLayers = [];
-            this._layers.forEach(({ feature, layer }) => {
+            var filteredLayers_1 = [];
+            this._layers.forEach(function (_a) {
+                var feature = _a.feature, layer = _a.layer;
                 if (layer) {
-                    const ok = fun
-                        ? fun({
-                            target: this,
-                            feature,
-                            layer,
-                            ...createFeaturePositionOptions(feature),
-                        })
+                    var ok = fun
+                        ? fun(__assign({ target: _this, feature: feature, layer: layer }, createFeaturePositionOptions(feature)))
                         : true;
                     if (ok) {
                         layer_.addLayer(layer);
-                        filteredLayers.push({
-                            target: this,
-                            feature,
-                            layer,
-                            ...createFeaturePositionOptions(feature),
-                        });
+                        filteredLayers_1.push(__assign({ target: _this, feature: feature, layer: layer }, createFeaturePositionOptions(feature)));
                     }
                     else {
                         layer_.removeLayer(layer);
                     }
                 }
             });
-            this._filteredLayers = filteredLayers;
+            this._filteredLayers = filteredLayers_1;
             layer_.addTo(map);
         }
         return this._filteredLayers;
-    }
-    cleanFilter() {
+    };
+    GeoJsonAdapter.prototype.cleanFilter = function () {
         this.filter();
-    }
-    getLayers() {
-        return this._layers.map(({ layer, feature }) => {
-            const visible = layer && !!layer._map;
-            return {
-                feature,
-                layer,
-                visible,
-                target: this,
-                ...createFeaturePositionOptions(feature),
-            };
+    };
+    GeoJsonAdapter.prototype.getLayers = function () {
+        var _this = this;
+        return this._layers.map(function (_a) {
+            var layer = _a.layer, feature = _a.feature;
+            var visible = layer && !!layer._map;
+            return __assign({ feature: feature, layer: layer, visible: visible, target: _this }, createFeaturePositionOptions(feature));
         });
-    }
-    clearLayer(cb) {
+    };
+    GeoJsonAdapter.prototype.clearLayer = function (cb) {
         this.unselect();
-        const layer_ = this.layer;
+        var layer_ = this.layer;
         if (layer_) {
             if (cb) {
-                for (let fry = this._layers.length; fry--;) {
-                    const def = this._layers[fry];
+                for (var fry = this._layers.length; fry--;) {
+                    var def = this._layers[fry];
                     if (def) {
-                        const { feature, layer } = def;
+                        var feature = def.feature, layer = def.layer;
                         if (feature && layer) {
-                            const exist = cb(feature);
+                            var exist = cb(feature);
                             if (exist) {
                                 layer_.removeLayer(layer);
                                 this._layers.splice(fry, 1);
@@ -391,19 +486,19 @@ class GeoJsonAdapter extends BaseAdapter {
                 this._layers = [];
             }
         }
-    }
-    setData(data) {
+    };
+    GeoJsonAdapter.prototype.setData = function (data) {
         this.clearLayer();
         this.addData(data);
-    }
-    addData(data) {
-        const options = this.options;
-        let geoJsonOptions;
+    };
+    GeoJsonAdapter.prototype.addData = function (data) {
+        var options = this.options;
+        var geoJsonOptions;
         if (options) {
             if (data) {
-                let type;
+                var type = void 0;
                 if (!options.type) {
-                    const detectedType = detectType(data);
+                    var detectedType = detectType(data);
                     type = typeAlias[detectedType];
                 }
                 else {
@@ -421,155 +516,166 @@ class GeoJsonAdapter extends BaseAdapter {
             }
             new GeoJSON(data || undefined, geoJsonOptions);
         }
-    }
-    openPopup(findFeatureFun, options) {
+    };
+    GeoJsonAdapter.prototype.openPopup = function (findFeatureFun, options) {
+        var _this = this;
         if (findFeatureFun) {
-            const def = this._layers.filter(findFeatureFun);
-            def.forEach((x) => {
-                this._openPopup(x, options, 'api');
+            var def = this._layers.filter(findFeatureFun);
+            def.forEach(function (x) {
+                _this._openPopup(x, options, 'api');
             });
         }
-    }
-    closePopup(findFeatureFun) {
-        const popupToClose = findFeatureFun
-            ? this._openedPopup.filter((x) => findFeatureFun(x[2]))
+    };
+    GeoJsonAdapter.prototype.closePopup = function (findFeatureFun) {
+        var _this = this;
+        var popupToClose = findFeatureFun
+            ? this._openedPopup.filter(function (x) { return findFeatureFun(x[2]); })
             : this._openedPopup;
-        popupToClose.forEach((x) => {
-            this._removePopup(x[0]);
+        popupToClose.forEach(function (x) {
+            _this._removePopup(x[0]);
         });
-    }
-    updateTooltip(layerDef) {
+    };
+    GeoJsonAdapter.prototype.updateTooltip = function (layerDef) {
+        var _this = this;
         if (layerDef) {
             this._updateTooltip(layerDef);
         }
         else {
-            this.getLayers().forEach((x) => this._updateTooltip({ feature: x.feature, layer: x.layer }));
+            this.getLayers().forEach(function (x) {
+                return _this._updateTooltip({ feature: x.feature, layer: x.layer });
+            });
         }
-    }
+    };
     /** @deprecated use {@link GeoJsonAdapter.getBounds} instead */
-    getExtent() {
+    GeoJsonAdapter.prototype.getExtent = function () {
         return this.getBounds();
-    }
-    getBounds() {
+    };
+    GeoJsonAdapter.prototype.getBounds = function () {
         if (this.layer) {
-            const bounds = this.layer.getBounds();
+            var bounds = this.layer.getBounds();
             if (bounds.isValid()) {
                 return boundsToArray(bounds);
             }
         }
-    }
-    setOpacity(value) {
+    };
+    GeoJsonAdapter.prototype.setOpacity = function (value) {
         this.options.opacity = value;
         this.setPaint(this.paint);
         this.setSelectedPaint(this.selectedPaint);
-    }
-    setPaint(paint) {
+    };
+    GeoJsonAdapter.prototype.setPaint = function (paint) {
         if (paint) {
             this.paint = paint;
-            for (const l of this._layers) {
+            for (var _i = 0, _a = this._layers; _i < _a.length; _i++) {
+                var l = _a[_i];
                 this._setPaint(l, paint);
             }
         }
-    }
-    setSelectedPaint(paint) {
+    };
+    GeoJsonAdapter.prototype.setSelectedPaint = function (paint) {
         if (paint) {
             this.selectedPaint = paint;
-            for (const l of this._selectedLayers) {
+            for (var _i = 0, _a = this._selectedLayers; _i < _a.length; _i++) {
+                var l = _a[_i];
                 this._setPaint(l, paint);
             }
         }
-    }
-    updatePaint(paint) {
-        this.paint = { ...this.paint, ...paint };
-        for (const l of this._layers) {
+    };
+    GeoJsonAdapter.prototype.updatePaint = function (paint) {
+        this.paint = __assign(__assign({}, this.paint), paint);
+        for (var _i = 0, _a = this._layers; _i < _a.length; _i++) {
+            var l = _a[_i];
             this._setPaint(l, this.paint);
         }
-    }
-    updateSelectedPaint(paint) {
-        this.selectedPaint = { ...this.selectedPaint, ...paint };
-        for (const l of this._selectedLayers) {
+    };
+    GeoJsonAdapter.prototype.updateSelectedPaint = function (paint) {
+        this.selectedPaint = __assign(__assign({}, this.selectedPaint), paint);
+        for (var _i = 0, _a = this._selectedLayers; _i < _a.length; _i++) {
+            var l = _a[_i];
             this._setPaint(l, this.selectedPaint);
         }
-    }
-    _updateTooltip(layerDef) {
-        const { feature, layer } = layerDef;
+    };
+    GeoJsonAdapter.prototype._updateTooltip = function (layerDef) {
+        var feature = layerDef.feature, layer = layerDef.layer;
         if (feature && layer && feature.properties && this.options.labelField) {
             layer.unbindTooltip();
-            const message = feature.properties[this.options.labelField];
+            var message = feature.properties[this.options.labelField];
             if (message !== undefined) {
-                const permanent = !this.options.labelOnHover;
-                layer.bindTooltip(String(message), { permanent, sticky: false });
+                var permanent = !this.options.labelOnHover;
+                layer.bindTooltip(String(message), { permanent: permanent, sticky: false });
             }
         }
-    }
-    async _openPopup(def, options = {}, type, latLng) {
+    };
+    GeoJsonAdapter.prototype._openPopup = function (def, options, type, latLng) {
         var _a, _b;
-        const { feature, layer } = def;
-        const { minWidth, autoPan, maxWidth, closeButton: closeButton_, } = {
-            minWidth: 300,
-            ...options,
-        };
-        const closeButton = closeButton_ !== null && closeButton_ !== void 0 ? closeButton_ : !this.options.selectOnHover;
-        let popup;
-        const _closeHandlers = [];
-        const onClose = (handler) => {
-            _closeHandlers.push(handler);
-        };
-        const close = () => {
-            if (popup) {
-                this._removePopup(popup);
-            }
-        };
-        let content;
-        if (options.createPopupContent) {
-            content = await options.createPopupContent({
-                layer,
-                feature,
-                target: this,
-                type,
-                close,
-                onClose,
-                ...createFeaturePositionOptions(feature),
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var feature, layer, _c, minWidth, autoPan, maxWidth, closeButton_, closeButton, popup, _closeHandlers, onClose, close, content, popupOptions, unselectOnClose, p;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        feature = def.feature, layer = def.layer;
+                        _c = __assign({ minWidth: 300 }, options), minWidth = _c.minWidth, autoPan = _c.autoPan, maxWidth = _c.maxWidth, closeButton_ = _c.closeButton;
+                        closeButton = closeButton_ !== null && closeButton_ !== void 0 ? closeButton_ : !this.options.selectOnHover;
+                        _closeHandlers = [];
+                        onClose = function (handler) {
+                            _closeHandlers.push(handler);
+                        };
+                        close = function () {
+                            if (popup) {
+                                _this._removePopup(popup);
+                            }
+                        };
+                        if (!options.createPopupContent) return [3 /*break*/, 2];
+                        return [4 /*yield*/, options.createPopupContent(__assign({ layer: layer, feature: feature, target: this, type: type, close: close, onClose: onClose }, createFeaturePositionOptions(feature)))];
+                    case 1:
+                        content = _d.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        content = options.popupContent;
+                        _d.label = 3;
+                    case 3:
+                        if (content && layer) {
+                            popupOptions = {
+                                minWidth: minWidth,
+                                autoPan: autoPan,
+                                // maxWidth,
+                                closeButton: closeButton,
+                                closeOnClick: false,
+                                autoClose: false,
+                            };
+                            if (defined(maxWidth)) {
+                                popupOptions.maxWidth = maxWidth;
+                            }
+                            popup = layer.bindPopup(content, popupOptions);
+                            unselectOnClose = (_b = (_a = this.options.popupOptions) === null || _a === void 0 ? void 0 : _a.unselectOnClose) !== null && _b !== void 0 ? _b : true;
+                            if (unselectOnClose) {
+                                p = layer.getPopup();
+                                p &&
+                                    p.once('remove', function () {
+                                        close();
+                                    }, this);
+                            }
+                            this._openedPopup.push([popup, _closeHandlers, def]);
+                            popup.openPopup(latLng);
+                        }
+                        return [2 /*return*/];
+                }
             });
-        }
-        else {
-            content = options.popupContent;
-        }
-        if (content && layer) {
-            const popupOptions = {
-                minWidth,
-                autoPan,
-                // maxWidth,
-                closeButton,
-                closeOnClick: false,
-                autoClose: false,
-            };
-            if (defined(maxWidth)) {
-                popupOptions.maxWidth = maxWidth;
-            }
-            popup = layer.bindPopup(content, popupOptions);
-            const unselectOnClose = (_b = (_a = this.options.popupOptions) === null || _a === void 0 ? void 0 : _a.unselectOnClose) !== null && _b !== void 0 ? _b : true;
-            if (unselectOnClose) {
-                const p = layer.getPopup();
-                p &&
-                    p.once('remove', () => {
-                        close();
-                    }, this);
-            }
-            this._openedPopup.push([popup, _closeHandlers, def]);
-            popup.openPopup(latLng);
-        }
-    }
-    _removePopup(popup) {
+        });
+    };
+    GeoJsonAdapter.prototype._removePopup = function (popup) {
         var _a, _b;
-        const map = this.map;
+        var map = this.map;
         if (map) {
             popup.closePopup().unbindPopup();
-            const index = this._openedPopup.findIndex((x) => x[0] === popup);
+            var index = this._openedPopup.findIndex(function (x) { return x[0] === popup; });
             if (index !== -1) {
-                const unselectOnClose = (_b = (_a = this.options.popupOptions) === null || _a === void 0 ? void 0 : _a.unselectOnClose) !== null && _b !== void 0 ? _b : true;
-                const [, closeHandlers, def] = this._openedPopup[index];
-                for (const h of closeHandlers) {
+                var unselectOnClose = (_b = (_a = this.options.popupOptions) === null || _a === void 0 ? void 0 : _a.unselectOnClose) !== null && _b !== void 0 ? _b : true;
+                var _c = this._openedPopup[index], closeHandlers = _c[1], def = _c[2];
+                for (var _i = 0, closeHandlers_1 = closeHandlers; _i < closeHandlers_1.length; _i++) {
+                    var h = closeHandlers_1[_i];
                     h(def);
                 }
                 closeHandlers.length = 0;
@@ -579,15 +685,16 @@ class GeoJsonAdapter extends BaseAdapter {
                 this._openedPopup.splice(index, 1);
             }
         }
-    }
-    _setPaintEachLayer(paint) {
-        this._layers.forEach((l) => {
-            this._setPaint(l, paint);
+    };
+    GeoJsonAdapter.prototype._setPaintEachLayer = function (paint) {
+        var _this = this;
+        this._layers.forEach(function (l) {
+            _this._setPaint(l, paint);
         });
-    }
-    _setPaint(def, paint) {
-        let style = undefined;
-        const { layer, feature } = def;
+    };
+    GeoJsonAdapter.prototype._setPaint = function (def, paint) {
+        var style = undefined;
+        var layer = def.layer, feature = def.feature;
         if (layer && feature) {
             if (isPaintCallback(paint)) {
                 style = paint(feature);
@@ -597,8 +704,8 @@ class GeoJsonAdapter extends BaseAdapter {
             }
             if (style) {
                 if (this.type === 'point' && style.type === 'icon') {
-                    const marker = layer;
-                    const divIcon = this._createDivIcon(style);
+                    var marker = layer;
+                    var divIcon = this._createDivIcon(style);
                     marker.setIcon(divIcon);
                 }
                 else if ('setStyle' in layer) {
@@ -606,14 +713,14 @@ class GeoJsonAdapter extends BaseAdapter {
                 }
             }
         }
-    }
-    _preparePaint(paint) {
+    };
+    GeoJsonAdapter.prototype._preparePaint = function (paint) {
         if (paint.type !== 'get-paint') {
             // const path: CircleMarkerOptions | PathOptions = paint as CircleMarkerOptions | PathOptions;
             // if (path.opacity) {
             //   path.fillOpacity = path.opacity;
             // }
-            const paintAliases = [
+            var paintAliases = [
                 // ['color', 'color'],
                 ['color', 'strokeColor'],
                 ['opacity', 'strokeOpacity'],
@@ -623,19 +730,20 @@ class GeoJsonAdapter extends BaseAdapter {
                 ['fill', 'fill'],
                 ['weight', 'weight'],
             ];
-            const aliases = this.type === 'line'
+            var aliases = this.type === 'line'
                 ? [
                     ['color', 'strokeColor'],
                     ['opacity', 'strokeOpacity'],
                     ['weight', 'weight'],
                 ]
                 : paintAliases;
-            const readyPaint = {};
+            var readyPaint = {};
             if ('radius' in paint && typeof paint.radius === 'number') {
                 readyPaint.radius = paint.radius;
             }
-            for (const [to, from] of aliases) {
-                let paintProp = paint[from];
+            for (var _i = 0, aliases_1 = aliases; _i < aliases_1.length; _i++) {
+                var _a = aliases_1[_i], to = _a[0], from = _a[1];
+                var paintProp = paint[from];
                 if (defined(this.options.opacity) &&
                     from.toLowerCase().indexOf('opacity') !== -1) {
                     paintProp = Number(paintProp) * this.options.opacity;
@@ -650,27 +758,28 @@ class GeoJsonAdapter extends BaseAdapter {
             return readyPaint;
         }
         return PAINT;
-    }
-    _getGeoJsonOptions(options, type) {
-        const paint = options.paint;
-        let lopt = {};
+    };
+    GeoJsonAdapter.prototype._getGeoJsonOptions = function (options, type) {
+        var _this = this;
+        var paint = options.paint;
+        var lopt = {};
         if (typeof paint === 'function') {
             if (type === 'point') {
                 // TODO: fix types (@geoman-io/leaflet-geoman-free)
-                lopt.pointToLayer = (feature, latLng) => {
-                    const iconOpt = paint(feature);
-                    const pointToLayer = this._createPaintToLayer(iconOpt);
+                lopt.pointToLayer = function (feature, latLng) {
+                    var iconOpt = paint(feature);
+                    var pointToLayer = _this._createPaintToLayer(iconOpt);
                     return pointToLayer(feature, latLng);
                 };
             }
             else {
                 lopt = {
-                    style: (feature) => {
+                    style: function (feature) {
                         if (feature) {
-                            return this._preparePaint({ ...PAINT, ...paint(feature) });
+                            return _this._preparePaint(__assign(__assign({}, PAINT), paint(feature)));
                         }
                         else {
-                            return this._preparePaint({ ...PAINT, type: 'path' });
+                            return _this._preparePaint(__assign(__assign({}, PAINT), { type: 'path' }));
                         }
                     },
                 };
@@ -679,106 +788,90 @@ class GeoJsonAdapter extends BaseAdapter {
         else {
             lopt = this._createPaintOptions(paint, type);
         }
-        lopt.onEachFeature = (feature, layer) => {
-            this._onEachFeature(feature, layer);
+        lopt.onEachFeature = function (feature, layer) {
+            _this._onEachFeature(feature, layer);
         };
         return lopt;
-    }
-    _onEachFeature(feature, layer) {
-        const layer_ = this.layer;
+    };
+    GeoJsonAdapter.prototype._onEachFeature = function (feature, layer) {
+        var _this = this;
+        var layer_ = this.layer;
         if (layer_) {
-            const def = {
-                target: this,
-                feature,
-                layer,
-                ...createFeaturePositionOptions(feature),
-            };
+            var def_1 = __assign({ target: this, feature: feature, layer: layer }, createFeaturePositionOptions(feature));
             // @ts-ignore
             layer.options.pane = this.pane;
-            this._layers.push(def);
-            let ok = true;
+            this._layers.push(def_1);
+            var ok = true;
             if (this._filterFun) {
-                ok = this._filterFun(def);
+                ok = this._filterFun(def_1);
             }
             if (ok) {
-                const { popup, popupOptions, selectable, interactive, selectOnHover } = this.options;
+                var _a = this.options, popup_1 = _a.popup, popupOptions_1 = _a.popupOptions, selectable = _a.selectable, interactive = _a.interactive, selectOnHover = _a.selectOnHover;
                 // @ts-ignore
                 layer.options.interactive = defined(interactive) ? interactive : true;
                 layer_.addLayer(layer);
                 if (selectable) {
                     if (selectOnHover) {
-                        layer.on('mouseover', () => {
-                            this._selectLayer(def, 'hover');
+                        layer.on('mouseover', function () {
+                            _this._selectLayer(def_1, 'hover');
                         });
-                        layer.on('mouseout', () => {
-                            this._unSelectLayer(def);
+                        layer.on('mouseout', function () {
+                            _this._unSelectLayer(def_1);
                         });
                     }
                     else {
-                        layer.on('click', (e) => this._selectOnLayerClick(e), this);
+                        layer.on('click', function (e) { return _this._selectOnLayerClick(e); }, this);
                     }
                 }
                 this._handleMouseEvents(layer);
                 // The timeout is needed to display the popup immediately when adding a layer to the map.
                 // Without a timeout, the layer may not yet have a _map object
-                setTimeout(() => {
-                    if (popup) {
-                        this._openPopup({
-                            target: this,
-                            layer,
-                            feature,
-                            ...createFeaturePositionOptions(feature),
-                        }, popupOptions, 'api');
+                setTimeout(function () {
+                    if (popup_1) {
+                        _this._openPopup(__assign({ target: _this, layer: layer, feature: feature }, createFeaturePositionOptions(feature)), popupOptions_1, 'api');
                     }
-                    this._updateTooltip({ layer, feature });
+                    _this._updateTooltip({ layer: layer, feature: feature });
                 });
             }
         }
-    }
-    _handleMouseEvents(layer) {
-        const { onClick, onLayerClick, onMouseOut, onMouseOver } = this.options;
+    };
+    GeoJsonAdapter.prototype._handleMouseEvents = function (layer) {
+        var _this = this;
+        var _a = this.options, onClick = _a.onClick, onLayerClick = _a.onLayerClick, onMouseOut = _a.onMouseOut, onMouseOver = _a.onMouseOver;
         // TODO: remove backward compatibility for onLayerClick
-        const onClick_ = onClick || onLayerClick;
+        var onClick_ = onClick || onLayerClick;
         if (onClick_) {
-            layer.on('click', (e) => {
-                const selected = !!this._getSelected(layer);
-                onClick_({
-                    selected,
-                    ...this._createMouseEvent(e),
-                });
+            layer.on('click', function (e) {
+                var selected = !!_this._getSelected(layer);
+                onClick_(__assign({ selected: selected }, _this._createMouseEvent(e)));
             }, this);
         }
         if (onMouseOut) {
-            layer.on('mouseout', (e) => {
-                onMouseOut(this._createMouseEvent(e));
+            layer.on('mouseout', function (e) {
+                onMouseOut(_this._createMouseEvent(e));
             }, this);
         }
         if (onMouseOver) {
-            layer.on('mouseover', (e) => {
-                onMouseOver(this._createMouseEvent(e));
+            layer.on('mouseover', function (e) {
+                onMouseOver(_this._createMouseEvent(e));
             }, this);
         }
-    }
-    _createMouseEvent(source) {
+    };
+    GeoJsonAdapter.prototype._createMouseEvent = function (source) {
         return createMouseEvent({
             layer: this,
             source: source,
         });
-    }
-    _getSelected(layer) {
-        return this._selectedLayers.find((x) => x.layer === layer);
-    }
-    _selectOnLayerClick(e) {
+    };
+    GeoJsonAdapter.prototype._getSelected = function (layer) {
+        return this._selectedLayers.find(function (x) { return x.layer === layer; });
+    };
+    GeoJsonAdapter.prototype._selectOnLayerClick = function (e) {
         DomEvent.stopPropagation(e);
-        const layer = e.target;
-        const feature = layer.feature;
-        const def = {
-            target: this,
-            layer,
-            feature,
-            ...createFeaturePositionOptions(feature),
-        };
-        const isSelected = this._getSelected(layer);
+        var layer = e.target;
+        var feature = layer.feature;
+        var def = __assign({ target: this, layer: layer, feature: feature }, createFeaturePositionOptions(feature));
+        var isSelected = this._getSelected(layer);
         if (isSelected) {
             if (this.options && this.options.unselectOnSecondClick) {
                 this._unSelectLayer(isSelected);
@@ -787,17 +880,18 @@ class GeoJsonAdapter extends BaseAdapter {
         else {
             this._selectLayer(def, 'click', e.latlng);
         }
-    }
-    _selectLayer(def, type, latlng) {
-        this.map._addUnselectCb(() => {
-            this._unSelectLayer(def);
+    };
+    GeoJsonAdapter.prototype._selectLayer = function (def, type, latlng) {
+        var _this = this;
+        this.map._addUnselectCb(function () {
+            _this._unSelectLayer(def);
         });
         if (this.options && !this.options.multiselect) {
-            this._selectedLayers.forEach((x) => this._unSelectLayer(x));
+            this._selectedLayers.forEach(function (x) { return _this._unSelectLayer(x); });
         }
         this._selectedLayers.push(def);
         this.selected = true;
-        const { selectedPaint, popupOnSelect, popupOptions } = this.options;
+        var _a = this.options, selectedPaint = _a.selectedPaint, popupOnSelect = _a.popupOnSelect, popupOptions = _a.popupOptions;
         if (selectedPaint && def.layer) {
             this._setPaint(def, selectedPaint);
         }
@@ -805,17 +899,12 @@ class GeoJsonAdapter extends BaseAdapter {
             this._openPopup(def, popupOptions, type, latlng);
         }
         if (this.options.onSelect) {
-            const features = def.feature ? [def.feature] : [];
-            this.options.onSelect({
-                type,
-                layer: this,
-                features,
-                ...createFeaturePositionOptions(features),
-            });
+            var features = def.feature ? [def.feature] : [];
+            this.options.onSelect(__assign({ type: type, layer: this, features: features }, createFeaturePositionOptions(features)));
         }
-    }
-    _unSelectLayer(def) {
-        const index = this._selectedLayers.indexOf(def);
+    };
+    GeoJsonAdapter.prototype._unSelectLayer = function (def) {
+        var index = this._selectedLayers.indexOf(def);
         if (index !== -1) {
             this._selectedLayers.splice(index, 1);
             if (this.options) {
@@ -828,40 +917,41 @@ class GeoJsonAdapter extends BaseAdapter {
             }
         }
         this.selected = this._selectedLayers.length > 0;
-    }
-    _createDivIcon(icon) {
-        const { ...toLIconOpt } = icon;
-        return new DivIcon({ className: '', ...toLIconOpt });
-    }
-    _createPaintToLayer(icon) {
+    };
+    GeoJsonAdapter.prototype._createDivIcon = function (icon) {
+        var toLIconOpt = __rest(icon, []);
+        return new DivIcon(__assign({ className: '' }, toLIconOpt));
+    };
+    GeoJsonAdapter.prototype._createPaintToLayer = function (icon) {
+        var _this = this;
         if (icon && icon.type) {
             if (icon.type === 'icon') {
-                const iconClassName = icon.className;
-                const html = icon.html;
+                var iconClassName = icon.className;
+                var html = icon.html;
                 if (iconClassName || html) {
-                    return (geoJsonPoint, latlng) => {
-                        const divIcon = this._createDivIcon(icon);
+                    return function (geoJsonPoint, latlng) {
+                        var divIcon = _this._createDivIcon(icon);
                         return new Marker(latlng, { icon: divIcon });
                     };
                 }
             }
             else if (icon.type === 'pin') {
-                return (geoJsonPoint, latlng) => {
+                return function (geoJsonPoint, latlng) {
                     // const divIcon = this.createDivIcon(icon);
                     return new Marker(latlng);
                 };
             }
         }
-        return (geoJsonPoint, latlng) => {
-            const p = PAINT;
-            return new CircleMarker(latlng, this._preparePaint({ ...p, ...icon }));
+        return function (geoJsonPoint, latlng) {
+            var p = PAINT;
+            return new CircleMarker(latlng, _this._preparePaint(__assign(__assign({}, p), icon)));
         };
-    }
-    _createPaintOptions(paintOptions, type) {
-        const geoJsonOptions = {};
-        const paint = (paintOptions && this._preparePaint(paintOptions)) || {};
+    };
+    GeoJsonAdapter.prototype._createPaintOptions = function (paintOptions, type) {
+        var geoJsonOptions = {};
+        var paint = (paintOptions && this._preparePaint(paintOptions)) || {};
         if (paintOptions) {
-            geoJsonOptions.style = () => {
+            geoJsonOptions.style = function () {
                 return paint;
             };
         }
@@ -872,12 +962,12 @@ class GeoJsonAdapter extends BaseAdapter {
             paint.stroke = true;
         }
         return geoJsonOptions;
-    }
-    _addMapListener() {
-        const map = this.map;
+    };
+    GeoJsonAdapter.prototype._addMapListener = function () {
+        var map = this.map;
         if (map) {
-            const { labelField, labelOnHover, unselectOnClick } = this.options;
-            const uoc = unselectOnClick !== null && unselectOnClick !== void 0 ? unselectOnClick : true;
+            var _a = this.options, labelField = _a.labelField, labelOnHover = _a.labelOnHover, unselectOnClick = _a.unselectOnClick;
+            var uoc = unselectOnClick !== null && unselectOnClick !== void 0 ? unselectOnClick : true;
             if (uoc) {
                 map.on('click', this.$unselect);
             }
@@ -886,62 +976,66 @@ class GeoJsonAdapter extends BaseAdapter {
                 map.on('moveend', this.$updateTooltip);
             }
         }
-    }
-    _removeMapListener() {
+    };
+    GeoJsonAdapter.prototype._removeMapListener = function () {
         this.map.off('zoomend', this.$updateTooltip);
         this.map.off('moveend', this.$updateTooltip);
         this.map.off('click', this.$unselect);
-    }
-}
+    };
+    return GeoJsonAdapter;
+}(BaseAdapter));
 
 function callAjax(src, callback, headers) {
-    const xhr = new XMLHttpRequest();
+    var xhr = new XMLHttpRequest();
     xhr.open('GET', src);
     xhr.responseType = 'arraybuffer';
-    for (const h in headers) {
+    for (var h in headers) {
         xhr.setRequestHeader(h, headers[h]);
     }
     xhr.onload = function () {
-        const arrayBufferView = new Uint8Array(this.response);
-        const blob = new Blob([arrayBufferView], { type: 'image/png' });
+        var arrayBufferView = new Uint8Array(this.response);
+        var blob = new Blob([arrayBufferView], { type: 'image/png' });
         // @ts-ignore for typedoc
-        const urlCreator = window.URL || window.webkitURL;
-        const imageUrl = urlCreator.createObjectURL(blob);
+        var urlCreator = window.URL || window.webkitURL;
+        var imageUrl = urlCreator.createObjectURL(blob);
         callback(imageUrl);
     };
     xhr.send();
-    return () => {
+    return function () {
         xhr.abort();
     };
 }
 
-class ImageOverlay extends ImageOverlay$1 {
-    constructor(imageUrl, bounds, options) {
-        super(imageUrl, bounds, options);
-        this._abort = [];
-    }
-    cancelLoad() {
+var ImageOverlay = /** @class */ (function (_super) {
+    __extends(ImageOverlay, _super);
+    function ImageOverlay(imageUrl, bounds, options) {
+        var _this = _super.call(this, imageUrl, bounds, options) || this;
+        _this._abort = [];
+        return _this;
+    }
+    ImageOverlay.prototype.cancelLoad = function () {
         if (this._abort) {
-            this._abort.forEach((x) => x());
+            this._abort.forEach(function (x) { return x(); });
             this._abort = [];
         }
-    }
-    _initImage() {
+    };
+    ImageOverlay.prototype._initImage = function () {
         // @ts-ignore
-        super._initImage();
+        _super.prototype._initImage.call(this);
         // @ts-ignore
-        const headers = this.options.headers;
+        var headers = this.options.headers;
         if (headers) {
             // @ts-ignore
-            const img = this._image;
-            const src = img.src;
-            img.src = '';
-            this._abort.push(callAjax(src, (response) => {
-                img.src = response;
+            var img_1 = this._image;
+            var src = img_1.src;
+            img_1.src = '';
+            this._abort.push(callAjax(src, function (response) {
+                img_1.src = response;
             }, headers));
         }
-    }
-}
+    };
+    return ImageOverlay;
+}(ImageOverlay$1));
 
 /*!
  * leaflet.wms.js
@@ -955,10 +1049,11 @@ class ImageOverlay extends ImageOverlay$1 {
  * Portions of wms.Overlay are directly extracted from L.TileLayer.WMS.
  * See Leaflet license.
  */
-class ImageLayer extends Layer {
-    constructor(url, options) {
-        super(options);
-        this.defaultWmsParams = {
+var ImageLayer = /** @class */ (function (_super) {
+    __extends(ImageLayer, _super);
+    function ImageLayer(url, options) {
+        var _this = _super.call(this, options) || this;
+        _this.defaultWmsParams = {
             service: 'WMS',
             request: 'GetMap',
             version: '1.1.1',
@@ -967,7 +1062,7 @@ class ImageLayer extends Layer {
             format: 'image/jpeg',
             transparent: false,
         };
-        this.options = {
+        _this.options = {
             crs: null,
             uppercase: false,
             attribution: '',
@@ -980,34 +1075,35 @@ class ImageLayer extends Layer {
             viewPortBuffer: 0,
             setViewDelay: 100,
         };
-        this._url = url;
+        _this._url = url;
         // Move WMS parameters to params object
-        const params = {};
-        const opts = {};
-        let opt;
+        var params = {};
+        var opts = {};
+        var opt;
         for (opt in options) {
-            if (opt in this.options) {
+            if (opt in _this.options) {
                 opts[opt] = options[opt];
             }
             else {
                 params[opt] = options[opt];
             }
         }
-        Util.setOptions(this, opts);
-        this.wmsParams = Util.extend({}, this.defaultWmsParams, params);
+        Util.setOptions(_this, opts);
+        _this.wmsParams = Util.extend({}, _this.defaultWmsParams, params);
+        return _this;
     }
-    setParams(params) {
+    ImageLayer.prototype.setParams = function (params) {
         Util.extend(this.wmsParams, params);
         this.update();
-    }
-    getAttribution() {
+    };
+    ImageLayer.prototype.getAttribution = function () {
         return this.options.attribution || '';
-    }
-    onAdd() {
+    };
+    ImageLayer.prototype.onAdd = function () {
         this.update();
         return this;
-    }
-    onRemove(map) {
+    };
+    ImageLayer.prototype.onRemove = function (map) {
         if (this._currentOverlay) {
             this._currentOverlay.cancelLoad();
             map.removeLayer(this._currentOverlay);
@@ -1017,28 +1113,29 @@ class ImageLayer extends Layer {
             delete this._currentUrl;
         }
         return this;
-    }
-    getEvents() {
+    };
+    ImageLayer.prototype.getEvents = function () {
         return {
             moveend: debounce$1(this.update, this.options.setViewDelay),
         };
-    }
-    update() {
+    };
+    ImageLayer.prototype.update = function () {
+        var _this = this;
         if (!this._map) {
             return;
         }
         // Determine image URL and whether it has changed since last update
         this.updateWmsParams();
-        const url = this.getImageUrl();
+        var url = this.getImageUrl();
         if (this._currentUrl === url) {
             return;
         }
         this._currentUrl = url;
         // Keep current image overlay in place until new one loads
         // (inspired by esri.leaflet)
-        const viewPortBuffer = this.options.viewPortBuffer || 0;
-        const bounds = this._map.getBounds().pad(viewPortBuffer);
-        const overlay = new ImageOverlay(url, bounds, {
+        var viewPortBuffer = this.options.viewPortBuffer || 0;
+        var bounds = this._map.getBounds().pad(viewPortBuffer);
+        var overlay = new ImageOverlay(url, bounds, {
             opacity: 0,
             pane: this.options.pane,
             headers: this.options.headers,
@@ -1047,82 +1144,82 @@ class ImageLayer extends Layer {
         if (this._currentOverlay) {
             this._currentOverlay.cancelLoad();
         }
-        overlay.once('load', () => {
-            if (!this._map) {
+        overlay.once('load', function () {
+            if (!_this._map) {
                 return;
             }
             // @ts-ignore
-            if (overlay._url !== this._currentUrl) {
-                this._map.removeLayer(overlay);
+            if (overlay._url !== _this._currentUrl) {
+                _this._map.removeLayer(overlay);
                 return;
             }
-            else if (this._currentOverlay) {
-                this._map.removeLayer(this._currentOverlay);
+            else if (_this._currentOverlay) {
+                _this._map.removeLayer(_this._currentOverlay);
             }
-            this._currentOverlay = overlay;
-            overlay.setOpacity(this.options.opacity !== undefined ? this.options.opacity : 1);
-            if (this.options.isBack === true) {
+            _this._currentOverlay = overlay;
+            overlay.setOpacity(_this.options.opacity !== undefined ? _this.options.opacity : 1);
+            if (_this.options.isBack === true) {
                 overlay.bringToBack();
             }
-            if (this.options.isBack === false) {
+            if (_this.options.isBack === false) {
                 overlay.bringToFront();
             }
-            if (this.options.zIndex !== undefined) {
-                overlay.setZIndex(this.options.zIndex);
+            if (_this.options.zIndex !== undefined) {
+                overlay.setZIndex(_this.options.zIndex);
             }
         }, this);
-        const { minZoom, maxZoom } = this.options;
+        var _a = this.options, minZoom = _a.minZoom, maxZoom = _a.maxZoom;
         if ((minZoom && this._map.getZoom() < minZoom) ||
             (maxZoom && this._map.getZoom() > maxZoom)) {
             this._map.removeLayer(overlay);
         }
-    }
-    setOpacity(opacity) {
+    };
+    ImageLayer.prototype.setOpacity = function (opacity) {
         this.options.opacity = opacity;
         if (this._currentOverlay) {
             this._currentOverlay.setOpacity(opacity);
         }
-    }
-    bringToBack() {
+    };
+    ImageLayer.prototype.bringToBack = function () {
         this.options.isBack = true;
         if (this._currentOverlay) {
             this._currentOverlay.bringToBack();
         }
-    }
-    bringToFront() {
+    };
+    ImageLayer.prototype.bringToFront = function () {
         this.options.isBack = false;
         if (this._currentOverlay) {
             this._currentOverlay.bringToFront();
         }
-    }
-    setZIndex(zIndex) {
+    };
+    ImageLayer.prototype.setZIndex = function (zIndex) {
         this.options.zIndex = zIndex;
         if (this._currentOverlay) {
             this._currentOverlay.setZIndex(zIndex);
         }
-    }
+    };
     // See L.TileLayer.WMS: onAdd() & getTileUrl()
-    updateWmsParams(map) {
+    ImageLayer.prototype.updateWmsParams = function (map) {
         if (!map) {
             map = this._map;
         }
         // Compute WMS options
-        const viewPortBuffer = this.options.viewPortBuffer || 0;
-        const bounds = map.getBounds().pad(viewPortBuffer);
-        const size = map.getSize();
+        var viewPortBuffer = this.options.viewPortBuffer || 0;
+        var bounds = map.getBounds().pad(viewPortBuffer);
+        var size = map.getSize();
         if (this.options.viewPortBuffer !== 0) {
-            const factor = viewPortBuffer + 1;
+            var factor = viewPortBuffer + 1;
             size.x = Math.ceil(size.x * factor);
             size.y = Math.ceil(size.y * factor);
         }
-        const wmsVersion = parseFloat(this.wmsParams.version);
-        const crs = this.options.crs || map.options.crs;
-        const projectionKey = wmsVersion >= 1.3 ? 'crs' : 'srs';
+        var wmsVersion = parseFloat(this.wmsParams.version);
+        var crs = this.options.crs || map.options.crs;
+        var projectionKey = wmsVersion >= 1.3 ? 'crs' : 'srs';
         if (crs) {
-            const nw = crs.project(bounds.getNorthWest());
-            const se = crs.project(bounds.getSouthEast());
+            var nw = crs.project(bounds.getNorthWest());
+            var se = crs.project(bounds.getSouthEast());
             // Assemble WMS parameter string
-            const params = {
+            var params = {
                 width: size.x,
                 height: size.y,
             };
@@ -1132,51 +1229,53 @@ class ImageLayer extends Layer {
                 : [nw.x, se.y, se.x, nw.y]).join(',');
             Util.extend(this.wmsParams, params);
         }
-    }
-    getImageUrl() {
-        const uppercase = this.options.uppercase || false;
-        const pstr = Util.getParamString(this.wmsParams, this._url, uppercase);
+    };
+    ImageLayer.prototype.getImageUrl = function () {
+        var uppercase = this.options.uppercase || false;
+        var pstr = Util.getParamString(this.wmsParams, this._url, uppercase);
         return this._url + pstr;
-    }
-}
+    };
+    return ImageLayer;
+}(Layer));
 
-class ImageAdapter extends BaseAdapter {
-    addLayer(options) {
-        const url = options && options.url;
+var ImageAdapter = /** @class */ (function (_super) {
+    __extends(ImageAdapter, _super);
+    function ImageAdapter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ImageAdapter.prototype.addLayer = function (options) {
+        var url = options && options.url;
         if (url) {
-            options = { transparent: true, ...options };
-            const updateWmsParamsFromOpt = options.updateWmsParams;
-            this.layer = new ImageLayer(url, {
-                pane: this.pane,
-                headers: options.headers,
-                setViewDelay: options.setViewDelay,
-                /**
-                 * TODO: safe remove, use only options.nativeOptions
-                 */
-                ...options,
-                ...options.params,
-                ...options.nativeOptions,
-            });
-            if (updateWmsParamsFromOpt) {
-                const updateWmsParams = this.layer.updateWmsParams;
+            options = __assign({ transparent: true }, options);
+            var updateWmsParamsFromOpt_1 = options.updateWmsParams;
+            this.layer = new ImageLayer(url, __assign(__assign(__assign({ pane: this.pane, headers: options.headers, setViewDelay: options.setViewDelay }, options), options.params), options.nativeOptions));
+            if (updateWmsParamsFromOpt_1) {
+                var updateWmsParams_1 = this.layer.updateWmsParams;
                 this.layer.updateWmsParams = function (map) {
-                    updateWmsParams.call(this, map);
-                    this.wmsParams = updateWmsParamsFromOpt(this.wmsParams);
+                    updateWmsParams_1.call(this, map);
+                    this.wmsParams = updateWmsParamsFromOpt_1(this.wmsParams);
                 };
             }
             return this.layer;
         }
-    }
-}
+    };
+    return ImageAdapter;
+}(BaseAdapter));
 
 // based on https://github.com/bvaughn/debounce-decorator
-function debounce(cb, wait = 10) {
-    let timeoutId;
-    function wrapper(...args) {
+function debounce(cb, wait) {
+    if (wait === void 0) { wait = 10; }
+    var timeoutId;
+    function wrapper() {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
         wrapper.clear();
-        timeoutId = setTimeout(() => {
+        timeoutId = setTimeout(function () {
             timeoutId = null;
-            cb.apply(this, args);
+            cb.apply(_this, args);
         }, wait);
     }
     wrapper.clear = function () {
@@ -1189,22 +1288,33 @@ function debounce(cb, wait = 10) {
 }
 
 function makeRemote(Base) {
-    return class RemoteTileLayer extends Base {
-        constructor(...args) {
-            super(...args);
-            if (this.options.setViewDelay) {
+    return /** @class */ (function (_super) {
+        __extends(RemoteTileLayer, _super);
+        function RemoteTileLayer() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var _this = _super.apply(this, args) || this;
+            if (_this.options.setViewDelay) {
                 // @ts-ignore
-                this._update = debounce((...a) => {
+                _this._update = debounce(function () {
+                    var _a;
+                    var a = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        a[_i] = arguments[_i];
+                    }
                     // @ts-ignore
-                    GridLayer.prototype._update.call(this, ...a);
-                }, this.options.setViewDelay);
+                    (_a = GridLayer.prototype._update).call.apply(_a, __spreadArray([_this], a, false));
+                }, _this.options.setViewDelay);
             }
+            return _this;
         }
-        createTile(coords, done) {
+        RemoteTileLayer.prototype.createTile = function (coords, done) {
             // @ts-ignore
-            const url = this.getTileUrl(coords);
-            const tile = document.createElement('img');
-            tile.abort = callAjax(url, (response) => {
+            var url = this.getTileUrl(coords);
+            var tile = document.createElement('img');
+            tile.abort = callAjax(url, function (response) {
                 tile.src = response;
                 done(null, tile);
             }, 
@@ -1217,15 +1327,15 @@ function makeRemote(Base) {
             tile.alt = '';
             tile.setAttribute('role', 'presentation');
             return tile;
-        }
-        _abortLoading() {
+        };
+        RemoteTileLayer.prototype._abortLoading = function () {
             // @ts-ignore
-            const tiles = this._tiles;
+            var tiles = this._tiles;
             // @ts-ignore
-            const tileZoom = this._tileZoom;
-            for (const i in tiles) {
+            var tileZoom = this._tileZoom;
+            for (var i in tiles) {
                 if (tiles[i].coords.z !== tileZoom) {
-                    const tile = tiles[i].el;
+                    var tile = tiles[i].el;
                     tile.onload = Util.falseFn;
                     tile.onerror = Util.falseFn;
                     if (!tile.complete) {
@@ -1238,41 +1348,39 @@ function makeRemote(Base) {
                     }
                 }
             }
-        }
-    };
+        };
+        return RemoteTileLayer;
+    }(Base));
 }
 
-class TileLayerBase extends TileLayer$1 {
-    constructor(urlTemplate, options) {
-        super(urlTemplate, options);
-        Object.assign(this.options, options);
-    }
-}
-const TileLayer = makeRemote(TileLayerBase);
+var TileLayerBase = /** @class */ (function (_super) {
+    __extends(TileLayerBase, _super);
+    function TileLayerBase(urlTemplate, options) {
+        var _this = _super.call(this, urlTemplate, options) || this;
+        Object.assign(_this.options, options);
+        return _this;
+    }
+    return TileLayerBase;
+}(TileLayer$1));
+var TileLayer = makeRemote(TileLayerBase);
 
-class TileAdapter extends BaseAdapter {
-    addLayer(options) {
+var TileAdapter = /** @class */ (function (_super) {
+    __extends(TileAdapter, _super);
+    function TileAdapter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TileAdapter.prototype.addLayer = function (options) {
         this.options = Object.assign(this.options, options);
         if (options) {
-            const { url, ...opt } = options;
+            var url = options.url, opt = __rest(options, ["url"]);
             if (url) {
-                const tileLayerOptions = {
-                    pane: this.pane,
-                    attribution: opt.attribution,
-                    minZoom: opt.minZoom,
-                    maxZoom: opt.maxZoom,
-                    ...opt.nativeOptions,
-                };
+                var tileLayerOptions = __assign({ pane: this.pane, attribution: opt.attribution, minZoom: opt.minZoom, maxZoom: opt.maxZoom }, opt.nativeOptions);
                 if (opt.subdomains) {
                     tileLayerOptions.subdomains = opt.subdomains;
                 }
-                let layer;
+                var layer = void 0;
                 if (opt.headers) {
-                    layer = new TileLayer(url, {
-                        ...tileLayerOptions,
-                        headers: opt.headers,
-                        setViewDelay: opt.setViewDelay,
-                    });
+                    layer = new TileLayer(url, __assign(__assign({}, tileLayerOptions), { headers: opt.headers, setViewDelay: opt.setViewDelay }));
                 }
                 else {
                     layer = new TileLayer$1(url, tileLayerOptions);
@@ -1280,57 +1388,57 @@ class TileAdapter extends BaseAdapter {
                 return layer;
             }
         }
-    }
-}
+    };
+    return TileAdapter;
+}(BaseAdapter));
 
-class WmsLayerBase extends TileLayer$1.WMS {
-    constructor(urlTemplate, options) {
-        super(urlTemplate, options);
-    }
-}
-const WmsLayer = makeRemote(WmsLayerBase);
+var WmsLayerBase = /** @class */ (function (_super) {
+    __extends(WmsLayerBase, _super);
+    function WmsLayerBase(urlTemplate, options) {
+        return _super.call(this, urlTemplate, options) || this;
+    }
+    return WmsLayerBase;
+}(TileLayer$1.WMS));
+var WmsLayer = makeRemote(WmsLayerBase);
 // applyMixins(WmsLayer, [RemoteTileLayer]);
 
-class WmsAdapter extends BaseAdapter {
-    addLayer(options) {
+var WmsAdapter = /** @class */ (function (_super) {
+    __extends(WmsAdapter, _super);
+    function WmsAdapter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WmsAdapter.prototype.addLayer = function (options) {
         Object.assign(this.options, options);
-        const { url, ...opt } = options;
+        var url = options.url, opt = __rest(options, ["url"]);
         if (url) {
-            const layerOptions = {
-                pane: this.pane,
-                attribution: opt.attribution,
-                minZoom: opt.minZoom,
-                maxZoom: opt.maxZoom,
-                layers: options.layers,
-                format: options.format,
-                ...options.nativeOptions,
-            };
-            let layer;
+            var layerOptions = __assign({ pane: this.pane, attribution: opt.attribution, minZoom: opt.minZoom, maxZoom: opt.maxZoom, layers: options.layers, format: options.format }, options.nativeOptions);
+            var layer = void 0;
             if (opt.headers) {
-                layer = new WmsLayer(url, { ...layerOptions, headers: opt.headers });
+                layer = new WmsLayer(url, __assign(__assign({}, layerOptions), { headers: opt.headers }));
             }
             else {
                 layer = new TileLayer$1.WMS(url, layerOptions);
             }
             return layer;
         }
-    }
-}
+    };
+    return WmsAdapter;
+}(BaseAdapter));
 
-class OsmAdapter extends TileAdapter {
-    addLayer(options) {
-        const url = 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
-        return super.addLayer({
-            name: 'OpenStreetMap',
-            attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
-            ...options,
-            url,
-        });
-    }
-}
+var OsmAdapter = /** @class */ (function (_super) {
+    __extends(OsmAdapter, _super);
+    function OsmAdapter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    OsmAdapter.prototype.addLayer = function (options) {
+        var url = 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
+        return _super.prototype.addLayer.call(this, __assign(__assign({ name: 'OpenStreetMap', attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors' }, options), { url: url }));
+    };
+    return OsmAdapter;
+}(TileAdapter));
 
 function arrayToBoundsExpression(bounds) {
-    const e = bounds;
+    var e = bounds;
     // top, left, bottom, right
     return [
         [e[3], e[0]],
@@ -1338,11 +1446,11 @@ function arrayToBoundsExpression(bounds) {
     ];
 }
 
-class LeafletMapAdapter$1 {
-    constructor() {
+var LeafletMapAdapter$1 = /** @class */ (function () {
+    function LeafletMapAdapter() {
         this.options = { target: 'map' };
-        this.layerAdapters = LeafletMapAdapter$1.layerAdapters;
-        this.controlAdapters = LeafletMapAdapter$1.controlAdapters;
+        this.layerAdapters = LeafletMapAdapter.layerAdapters;
+        this.controlAdapters = LeafletMapAdapter.controlAdapters;
         this.emitter = new EventEmitter();
         this._unselectCb = [];
         this._universalEvents = [
@@ -1354,58 +1462,50 @@ class LeafletMapAdapter$1 {
             'movestart',
         ];
     }
-    create(options) {
-        this.options = { ...options };
+    LeafletMapAdapter.prototype.create = function (options) {
+        var _this = this;
+        this.options = __assign({}, options);
         if (this.options.target) {
-            const { zoom, center, maxZoom, minZoom, maxBounds: mb, mapAdapterOptions, } = this.options;
-            this.map = new Map(this.options.target, {
-                attributionControl: false,
-                zoomControl: false,
-                maxBounds: mb ? arrayToBoundsExpression(mb) : undefined,
-                maxZoom,
-                minZoom,
-                center: center && [center[1], center[0]],
-                zoom,
-                ...mapAdapterOptions,
-            });
+            var _a = this.options, zoom = _a.zoom, center = _a.center, maxZoom = _a.maxZoom, minZoom = _a.minZoom, mb = _a.maxBounds, mapAdapterOptions = _a.mapAdapterOptions;
+            this.map = new Map(this.options.target, __assign({ attributionControl: false, zoomControl: false, maxBounds: mb ? arrayToBoundsExpression(mb) : undefined, maxZoom: maxZoom, minZoom: minZoom, center: center && [center[1], center[0]], zoom: zoom }, mapAdapterOptions));
             // create default pane
-            const defPane = this.map.createPane('order-0');
-            this.map._addUnselectCb = (def) => {
-                this._addUnselectCb(def);
+            var defPane = this.map.createPane('order-0');
+            this.map._addUnselectCb = function (def) {
+                _this._addUnselectCb(def);
             };
             defPane.style.zIndex = String(0);
             this.emitter.emit('create', this);
             this._addMapListeners();
         }
-    }
-    destroy() {
+    };
+    LeafletMapAdapter.prototype.destroy = function () {
         if (this.map) {
             this.map.remove();
         }
         this._stopWatchSizeChangeToUpdateMinZoom();
-    }
-    getContainer() {
+    };
+    LeafletMapAdapter.prototype.getContainer = function () {
         return this.map && this.map.getContainer();
-    }
-    getControlContainer() {
-        const controlContainer = this.map && this.map._controlContainer;
+    };
+    LeafletMapAdapter.prototype.getControlContainer = function () {
+        var controlContainer = this.map && this.map._controlContainer;
         if (controlContainer) {
             return controlContainer;
         }
         throw new Error('Leaflet Map is not initialized yet');
-    }
-    setCursor(cursor) {
+    };
+    LeafletMapAdapter.prototype.setCursor = function (cursor) {
         if (this.map) {
             this.map.getContainer().style.cursor = cursor;
         }
-    }
-    setView(lngLatOrOpt, zoom) {
-        const map = this.map;
+    };
+    LeafletMapAdapter.prototype.setView = function (lngLatOrOpt, zoom) {
+        var map = this.map;
         if (!map)
             return;
         if (Array.isArray(lngLatOrOpt)) {
-            const lngLat = lngLatOrOpt;
-            const [lng, lat] = lngLat;
+            var lngLat = lngLatOrOpt;
+            var lng = lngLat[0], lat = lngLat[1];
             if (this.map) {
                 if (typeof zoom === 'number') {
                     this.map.setView([lat, lng], zoom, { animate: false });
@@ -1416,13 +1516,13 @@ class LeafletMapAdapter$1 {
             }
         }
         else {
-            const { zoom, center, maxBounds, bounds, minZoom, maxZoom } = lngLatOrOpt;
-            if (center && zoom !== undefined) {
-                this.setView(center, zoom);
+            var zoom_1 = lngLatOrOpt.zoom, center = lngLatOrOpt.center, maxBounds = lngLatOrOpt.maxBounds, bounds = lngLatOrOpt.bounds, minZoom = lngLatOrOpt.minZoom, maxZoom = lngLatOrOpt.maxZoom;
+            if (center && zoom_1 !== undefined) {
+                this.setView(center, zoom_1);
             }
             else {
-                if (zoom !== undefined) {
-                    this.setZoom(zoom);
+                if (zoom_1 !== undefined) {
+                    this.setZoom(zoom_1);
                 }
                 if (center) {
                     this.setCenter(center);
@@ -1433,7 +1533,7 @@ class LeafletMapAdapter$1 {
             }
             if (maxBounds !== undefined) {
                 if (maxBounds) {
-                    const b = arrayToBoundsExpression(maxBounds);
+                    var b = arrayToBoundsExpression(maxBounds);
                     map.setMaxBounds(b);
                     map.setMinZoom(map.getBoundsZoom(b));
                     this._watchSizeChangeToUpdateMinZoom(b);
@@ -1452,42 +1552,43 @@ class LeafletMapAdapter$1 {
                 map.setMinZoom(minZoom);
             }
         }
-    }
-    setCenter(lngLat) {
-        const [lng, lat] = lngLat;
+    };
+    LeafletMapAdapter.prototype.setCenter = function (lngLat) {
+        var lng = lngLat[0], lat = lngLat[1];
         if (this.map) {
             this.map.panTo([lat, lng]);
         }
-    }
-    getCenter() {
-        const map = this.map;
+    };
+    LeafletMapAdapter.prototype.getCenter = function () {
+        var map = this.map;
         if (map) {
-            const bounds = map.getBounds();
-            const center = bounds.getCenter();
+            var bounds = map.getBounds();
+            var center = bounds.getCenter();
             return [center.lng, center.lat];
         }
-    }
-    setZoom(zoom) {
+    };
+    LeafletMapAdapter.prototype.setZoom = function (zoom) {
         if (this.map) {
             this.map.setZoom(zoom);
         }
-    }
-    getZoom() {
+    };
+    LeafletMapAdapter.prototype.getZoom = function () {
         return (this.map && this.map.getZoom()) || undefined;
-    }
-    getBounds() {
+    };
+    LeafletMapAdapter.prototype.getBounds = function () {
         if (!this.map)
             return undefined;
-        const b = this.map.getBounds();
-        const sw = b.getSouthWest();
-        const ne = b.getNorthEast();
+        var b = this.map.getBounds();
+        var sw = b.getSouthWest();
+        var ne = b.getNorthEast();
         return [sw.lng, sw.lat, ne.lng, ne.lat];
-    }
+    };
     // [west, south, east, north]
-    fitBounds(bounds, options = {}) {
+    LeafletMapAdapter.prototype.fitBounds = function (bounds, options) {
+        if (options === void 0) { options = {}; }
         if (this.map) {
-            const { maxZoom, offset, padding } = options;
-            const opt = {};
+            var maxZoom = options.maxZoom, offset = options.offset, padding = options.padding;
+            var opt = {};
             if (maxZoom) {
                 opt.maxZoom = maxZoom;
             }
@@ -1499,103 +1600,104 @@ class LeafletMapAdapter$1 {
             }
             this.map.fitBounds(arrayToBoundsExpression(bounds), opt);
         }
-    }
-    getLayerAdapter(name) {
-        return LeafletMapAdapter$1.layerAdapters[name];
-    }
-    createControl(control, options) {
+    };
+    LeafletMapAdapter.prototype.getLayerAdapter = function (name) {
+        return LeafletMapAdapter.layerAdapters[name];
+    };
+    LeafletMapAdapter.prototype.createControl = function (control, options) {
         return createControl(control, options, this);
-    }
-    createButtonControl(options) {
+    };
+    LeafletMapAdapter.prototype.createButtonControl = function (options) {
         return createButtonControl(options, this);
-    }
-    addControl(control, position) {
+    };
+    LeafletMapAdapter.prototype.addControl = function (control, position) {
         control.options.position = position.replace('-', '');
         if (this.map) {
             this.map.addControl(control);
             return control;
         }
-    }
-    removeControl(control) {
+    };
+    LeafletMapAdapter.prototype.removeControl = function (control) {
         if (this.map) {
             this.map.removeControl(control);
         }
-    }
-    removeLayer(layer) {
+    };
+    LeafletMapAdapter.prototype.removeLayer = function (layer) {
         layer && layer.remove && layer.remove();
-    }
-    showLayer(layer) {
+    };
+    LeafletMapAdapter.prototype.showLayer = function (layer) {
         if (this.map) {
             layer.addTo(this.map);
         }
-    }
-    hideLayer(layer) {
+    };
+    LeafletMapAdapter.prototype.hideLayer = function (layer) {
         layer.remove();
-    }
-    setLayerOpacity(layer, value) {
+    };
+    LeafletMapAdapter.prototype.setLayerOpacity = function (layer, value) {
         if ('setOpacity' in layer) {
             layer.setOpacity(value);
         }
-    }
-    setLayerOrder(layer, order, layers) {
+    };
+    LeafletMapAdapter.prototype.setLayerOrder = function (layer, order, layers) {
         //
-    }
-    onMapClick(evt) {
-        const converted = convertMapClickEvent(evt);
+    };
+    LeafletMapAdapter.prototype.onMapClick = function (evt) {
+        var converted = convertMapClickEvent(evt);
         this.emitter.emit('preclick', converted);
         this.emitter.emit('click', converted);
-    }
-    locate(opt, events) {
-        const map = this.map;
+    };
+    LeafletMapAdapter.prototype.locate = function (opt, events) {
+        var map = this.map;
         if (map) {
             map.locate(opt);
             if (events) {
-                const { locationfound, locationerror } = events;
-                const locationFound = (e) => {
-                    const event = e;
-                    const lngLat = [event.latlng.lng, event.latlng.lat];
-                    locationfound({ lngLat });
+                var locationfound_1 = events.locationfound, locationerror_1 = events.locationerror;
+                var locationFound_1 = function (e) {
+                    var event = e;
+                    var lngLat = [event.latlng.lng, event.latlng.lat];
+                    locationfound_1({ lngLat: lngLat });
                 };
-                if (locationfound !== undefined) {
-                    map.on('locationfound', locationFound, this);
+                if (locationfound_1 !== undefined) {
+                    map.on('locationfound', locationFound_1, this);
                 }
-                if (locationerror) {
-                    map.on('locationerror', locationerror, this);
+                if (locationerror_1) {
+                    map.on('locationerror', locationerror_1, this);
                 }
-                const stop = () => {
-                    if (locationfound !== undefined) {
-                        map.off('locationfound', locationFound);
+                var stop_1 = function () {
+                    if (locationfound_1 !== undefined) {
+                        map.off('locationfound', locationFound_1);
                     }
-                    if (locationerror) {
-                        map.off('locationerror', locationerror);
+                    if (locationerror_1) {
+                        map.off('locationerror', locationerror_1);
                     }
                 };
-                return { stop };
+                return { stop: stop_1 };
             }
         }
-        const stop = () => void 'fake function';
-        return { stop };
-    }
-    _addUnselectCb(cb) {
-        for (const p of this._unselectCb) {
+        var stop = function () { return void 'fake function'; };
+        return { stop: stop };
+    };
+    LeafletMapAdapter.prototype._addUnselectCb = function (cb) {
+        for (var _i = 0, _a = this._unselectCb; _i < _a.length; _i++) {
+            var p = _a[_i];
             p();
         }
         this._unselectCb.length = 0;
         this._unselectCb.push(cb);
-    }
-    _watchSizeChangeToUpdateMinZoom(bounds) {
+    };
+    LeafletMapAdapter.prototype._watchSizeChangeToUpdateMinZoom = function (bounds) {
         this._stopWatchSizeChangeToUpdateMinZoom();
-        const container = this.getContainer();
-        const map = this.map;
+        var container = this.getContainer();
+        var map = this.map;
         if (container && map && window.ResizeObserver) {
-            this._resizeObserver = new ResizeObserver(() => {
+            this._resizeObserver = new ResizeObserver(function () {
                 map.setMinZoom(map.getBoundsZoom(bounds));
             });
             this._resizeObserver.observe(container);
         }
-    }
-    _stopWatchSizeChangeToUpdateMinZoom() {
-        const map = this.map;
+    };
+    LeafletMapAdapter.prototype._stopWatchSizeChangeToUpdateMinZoom = function () {
+        var map = this.map;
         if (map) {
             map.setMinZoom(0);
         }
@@ -1603,32 +1705,34 @@ class LeafletMapAdapter$1 {
             this._resizeObserver.disconnect();
             this._resizeObserver = undefined;
         }
-    }
-    _addMapListeners() {
-        const map = this.map;
+    };
+    LeafletMapAdapter.prototype._addMapListeners = function () {
+        var _this = this;
+        var map = this.map;
         if (map) {
-            map.on('click', (evt) => {
-                this.onMapClick(evt);
+            map.on('click', function (evt) {
+                _this.onMapClick(evt);
             });
-            this._universalEvents.forEach((e) => {
-                map.on(e, () => this.emitter.emit(e, this), map);
+            this._universalEvents.forEach(function (e) {
+                map.on(e, function () { return _this.emitter.emit(e, _this); }, map);
             });
         }
-    }
-}
-LeafletMapAdapter$1.layerAdapters = {
-    GEOJSON: GeoJsonAdapter,
-    IMAGE: ImageAdapter,
-    TILE: TileAdapter,
-    WMS: WmsAdapter,
-    // // MVT: MvtAdapter,
-    OSM: OsmAdapter,
-};
-LeafletMapAdapter$1.controlAdapters = {
-    ZOOM: Control.Zoom,
-    ATTRIBUTION: AttributionControl,
-};
-LeafletMapAdapter$1.Map = Map;
+    };
+    LeafletMapAdapter.layerAdapters = {
+        GEOJSON: GeoJsonAdapter,
+        IMAGE: ImageAdapter,
+        TILE: TileAdapter,
+        WMS: WmsAdapter,
+        // // MVT: MvtAdapter,
+        OSM: OsmAdapter,
+    };
+    LeafletMapAdapter.controlAdapters = {
+        ZOOM: Control.Zoom,
+        ATTRIBUTION: AttributionControl,
+    };
+    LeafletMapAdapter.Map = Map;
+    return LeafletMapAdapter;
+}());
 
 /**
  * @module leaflet-map-adapter