@nextgis/leaflet-map-adapter 1.16.9 → 1.18.0

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

@@ -1,1776 +1,1665 @@
-/** Bundle of @nextgis/leaflet-map-adapter; version: 1.16.9; author: NextGIS */
+/** Bundle of @nextgis/leaflet-map-adapter; version: 1.18.0; author: NextGIS */
 import { EventEmitter } from 'events';
-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 { 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 { 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;
+    return {
+        latLng,
+        lngLat: [lng, lat],
+        pixel: { left: coord.x, top: coord.y },
+        source: evt,
+    };
 }
 
-function convertMapClickEvent(evt) {
-    var coord = evt.containerPoint;
-    var latLng = evt.latlng;
-    var lat = latLng.lat, lng = latLng.lng;
-    return {
-        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);
+            element.classList.add('leaflet-control');
+            if (options.bar) {
+                element.classList.add('leaflet-bar');
+            }
+            if (options.addClass) {
+                element.classList.add(options.addClass);
+            }
+            if (!options.margin && !options.bar) {
+                element.style.marginBottom = '0px';
+                element.style.marginTop = '0px';
+                element.style.marginLeft = '0px';
+                element.style.marginRight = '0px';
+            }
+            if (content) {
+                element.appendChild(content);
+            }
+            DomEvent.disableClickPropagation(element);
+            return element;
+        },
+        onRemove() {
+            control.onRemove();
+        },
+    });
+    return new C();
 }
 
-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');
-            }
-            if (options.addClass) {
-                element.classList.add(options.addClass);
-            }
-            if (!options.margin && !options.bar) {
-                element.style.marginBottom = '0px';
-                element.style.marginTop = '0px';
-                element.style.marginLeft = '0px';
-                element.style.marginRight = '0px';
-            }
-            if (content) {
-                element.appendChild(content);
-            }
-            DomEvent.disableClickPropagation(element);
-            return element;
-        },
-        onRemove: function () {
-            control.onRemove();
-        },
-    });
-    return new C();
+function createButtonControl(options, map) {
+    const link = document.createElement('a');
+    const 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) {
+        link.appendChild(options.html);
+    }
+    else if (typeof options.html === 'string') {
+        link.innerHTML = options.html;
+    }
+    const onClick = (e) => {
+        e.stopPropagation();
+        options.onClick();
+    };
+    return createControl({
+        onAdd() {
+            if (options.onClick !== undefined) {
+                link.addEventListener('click', onClick);
+            }
+            return link;
+        },
+        onRemove() {
+            const parent = link.parentNode;
+            if (parent) {
+                parent.removeChild(link);
+            }
+            if (options.onClick !== undefined) {
+                link.removeEventListener('click', onClick);
+            }
+        },
+    }, { bar: true }, map);
 }
 
-function createButtonControl(options, map) {
-    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) {
-        link.appendChild(options.html);
-    }
-    else if (typeof options.html === 'string') {
-        link.innerHTML = options.html;
-    }
-    var onClick = function (e) {
-        e.stopPropagation();
-        options.onClick();
-    };
-    return createControl({
-        onAdd: function () {
-            if (options.onClick !== undefined) {
-                link.addEventListener('click', onClick);
-            }
-            return link;
-        },
-        onRemove: function () {
-            var parent = link.parentNode;
-            if (parent) {
-                parent.removeChild(link);
-            }
-            if (options.onClick !== undefined) {
-                link.removeEventListener('click', onClick);
-            }
-        },
-    }, { bar: true }, map);
+class AttributionControl extends Control.Attribution {
+    // options: AttributionControlOptions
+    constructor(options) {
+        super(options);
+        const customAttribution = options && options.customAttribution;
+        if (customAttribution) {
+            let attributions = [];
+            if (Array.isArray(customAttribution)) {
+                attributions = customAttribution;
+            }
+            else if (customAttribution) {
+                attributions = [customAttribution];
+            }
+            attributions.forEach((x) => this.addAttribution(x));
+        }
+    }
 }
 
-var AttributionControl = /** @class */ (function (_super) {
-    __extends(AttributionControl, _super);
-    // options: AttributionControlOptions
-    function AttributionControl(options) {
-        var _this = _super.call(this, options) || this;
-        var customAttribution = options && options.customAttribution;
-        if (customAttribution) {
-            var attributions = [];
-            if (Array.isArray(customAttribution)) {
-                attributions = customAttribution;
-            }
-            else if (customAttribution) {
-                attributions = [customAttribution];
-            }
-            attributions.forEach(function (x) { return _this.addAttribution(x); });
-        }
-        return _this;
-    }
-    return AttributionControl;
-}(Control.Attribution));
-
-function boundsToArray(bounds) {
-    var ne = bounds.getNorthEast();
-    var sw = bounds.getSouthWest();
-    return [sw.lng, sw.lat, ne.lng, ne.lat];
+function boundsToArray(bounds) {
+    const ne = bounds.getNorthEast();
+    const sw = bounds.getSouthWest();
+    return [sw.lng, sw.lat, ne.lng, ne.lat];
 }
 
-var typeAlias = {
-    Point: 'point',
-    LineString: 'line',
-    MultiPoint: 'point',
-    Polygon: 'polygon',
-    MultiLineString: 'line',
-    MultiPolygon: 'polygon',
-    GeometryCollection: 'polygon',
-};
-var PAINT = {
-    stroke: false,
-    opacity: 1,
-};
-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) {
-    var geoJsonGeometry = backAliases[type] || [];
-    return geoJsonGeometry.indexOf(geometry) !== -1;
-}
-function filterGeometries(data, type) {
-    if (data.type === 'FeatureCollection') {
-        var _data = data;
-        _data.features = _data.features.filter(function (f) {
-            return geometryFilter(f.geometry.type, type);
-        });
-    }
-    else if (data.type === 'Feature') {
-        var allow = geometryFilter(data.geometry.type, type);
-        if (!allow) {
-            return false;
-        }
-    }
-    else if (data.type === 'GeometryCollection') {
-        var _data = data;
-        _data.geometries = _data.geometries.filter(function (g) {
-            return geometryFilter(g.type, type);
-        });
-    }
-    return data;
-}
-function featuresBounds(features) {
-    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) {
-    var _a = featuresBounds(features).getCenter(), lat = _a.lat, lng = _a.lng;
-    return [lng, lat];
-}
-function createFeaturePositionOptions(features) {
-    return {
-        getBounds: function () { return getFeaturesBounds(features); },
-        getCenter: function () { return getFeaturesCenter(features); },
-    };
+const typeAlias = {
+    Point: 'point',
+    LineString: 'line',
+    MultiPoint: 'point',
+    Polygon: 'polygon',
+    MultiLineString: 'line',
+    MultiPolygon: 'polygon',
+    GeometryCollection: 'polygon',
+};
+const PAINT = {
+    stroke: false,
+    opacity: 1,
+};
+const backAliases = {};
+for (const a in typeAlias) {
+    const layerType = typeAlias[a];
+    const backAlias = backAliases[layerType] || [];
+    backAlias.push(a);
+    backAliases[layerType] = backAlias;
+}
+function geometryFilter(geometry, type) {
+    const 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));
+    }
+    else if (data.type === 'Feature') {
+        const 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));
+    }
+    return data;
+}
+function featuresBounds(features) {
+    const geoJsonLayer = new GeoJSON();
+    const features_ = Array.isArray(features) ? features : [features];
+    features_.forEach((f) => geoJsonLayer.addData(f));
+    return geoJsonLayer.getBounds();
+}
+function getFeaturesBounds(features) {
+    return boundsToArray(featuresBounds(features));
+}
+function getFeaturesCenter(features) {
+    const { lat, lng } = featuresBounds(features).getCenter();
+    return [lng, lat];
+}
+function createFeaturePositionOptions(features) {
+    return {
+        getBounds: () => getFeaturesBounds(features),
+        getCenter: () => getFeaturesCenter(features),
+    };
 }
 
-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 createMouseEvent({ layer, source, }) {
+    const layer_ = source.target;
+    const feature = layer_.feature;
+    const opt = {
+        layer,
+        feature,
+        event: convertMapClickEvent(source),
+        source,
+        ...createFeaturePositionOptions(feature),
+    };
+    return opt;
 }
 
-function findMostFrequentGeomType(arr) {
-    var counts = {};
-    for (var fry = 0; fry < arr.length; fry++) {
-        counts[arr[fry]] = 1 + (counts[arr[fry]] || 0);
-    }
-    var maxName = '';
-    for (var c in counts) {
-        var maxCount = maxName ? counts[maxName] : 0;
-        if (counts[c] > maxCount) {
-            maxName = c;
-        }
-    }
-    return maxName;
-}
-function detectType(geojson) {
-    var geometry;
-    if (geojson.type === 'FeatureCollection') {
-        var featuresTypes = geojson.features.map(function (f) { return f.geometry.type; });
-        geometry = findMostFrequentGeomType(featuresTypes);
-    }
-    else if (geojson.type === 'GeometryCollection') {
-        var geometryTypes = geojson.geometries.map(function (g) { return g.type; });
-        geometry = findMostFrequentGeomType(geometryTypes);
-    }
-    else if (geojson.type === 'Feature') {
-        geometry = geojson.geometry.type;
-    }
-    else {
-        geometry = geojson.type;
-    }
-    return geometry;
+function findMostFrequentGeomType(arr) {
+    const counts = {};
+    for (let 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;
+        if (counts[c] > maxCount) {
+            maxName = c;
+        }
+    }
+    return maxName;
+}
+function detectType(geojson) {
+    let geometry;
+    if (geojson.type === 'FeatureCollection') {
+        const featuresTypes = geojson.features.map((f) => f.geometry.type);
+        geometry = findMostFrequentGeomType(featuresTypes);
+    }
+    else if (geojson.type === 'GeometryCollection') {
+        const geometryTypes = geojson.geometries.map((g) => g.type);
+        geometry = findMostFrequentGeomType(geometryTypes);
+    }
+    else if (geojson.type === 'Feature') {
+        geometry = geojson.geometry.type;
+    }
+    else {
+        geometry = geojson.type;
+    }
+    return geometry;
 }
 
-var BaseAdapter = /** @class */ (function () {
-    function BaseAdapter(map, options) {
-        this.map = map;
-        this.options = options;
-        this.pane = 'order-0';
-        if (options.order !== undefined) {
-            var pane = 'order-' + options.order;
-            var exist = map.getPane(pane);
-            if (!exist) {
-                exist = map.createPane(pane);
-            }
-            exist.style.zIndex = String(Math.round(options.order * 100));
-            this.pane = pane;
-        }
-    }
-    BaseAdapter.prototype.addLayer = function (options) {
-        Object.assign(this.options, options);
-        return undefined;
-    };
-    return BaseAdapter;
-}());
+class BaseAdapter {
+    constructor(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);
+            if (!exist) {
+                exist = map.createPane(pane);
+            }
+            exist.style.zIndex = String(Math.round(options.order * 100));
+            this.pane = pane;
+        }
+    }
+    addLayer(options) {
+        Object.assign(this.options, options);
+        return undefined;
+    }
+}
 
-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 = function () {
-            _this.unselect();
-        };
-        return _this;
-    }
-    GeoJsonAdapter.prototype.addLayer = function (options) {
-        Object.assign(this.options, options);
-        this.paint = options.paint;
-        this.layer = new FeatureGroup([], __assign(__assign({}, options.nativeOptions), { pane: this.pane }));
-        this.selectedPaint = options.selectedPaint;
-        options.paint = this.paint;
-        if (options.data) {
-            this.addData(options.data);
-        }
-        this._addMapListener();
-        return this.layer;
-    };
-    GeoJsonAdapter.prototype.beforeRemove = function () {
-        this._removeMapListener();
-    };
-    GeoJsonAdapter.prototype.select = function (findFeatureFun) {
-        this.unselect();
-        if (findFeatureFun) {
-            var def = this._layers.filter(findFeatureFun);
-            for (var _i = 0, def_1 = def; _i < def_1.length; _i++) {
-                var x = def_1[_i];
-                this._selectLayer(x, 'api');
-            }
-        }
-        else if (!this.selected) {
-            this.selected = true;
-            if (this.selectedPaint) {
-                this._setPaintEachLayer(this.selectedPaint);
-            }
-        }
-    };
-    GeoJsonAdapter.prototype.unselect = function (findFeatureFun) {
-        var _this = this;
-        if (findFeatureFun) {
-            var feature = this._layers.filter(findFeatureFun);
-            feature.forEach(function (x) {
-                _this._unSelectLayer(x);
-            });
-        }
-        else if (this.selected) {
-            for (var _i = 0, _a = this._openedPopup; _i < _a.length; _i++) {
-                var p = _a[_i];
-                this._removePopup(p[0]);
-            }
-            if (this.paint) {
-                this._setPaintEachLayer(this.paint);
-            }
-            this._selectedLayers.length = 0;
-            this.selected = false;
-        }
-    };
-    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));
-        });
-    };
-    GeoJsonAdapter.prototype.getFiltered = function () {
-        return this._filteredLayers;
-    };
-    GeoJsonAdapter.prototype.filter = function (fun) {
-        var _this = this;
-        // Some optimization
-        this._filterFun = fun;
-        var layer_ = this.layer;
-        var map = layer_ && layer_._map;
-        if (layer_ && map) {
-            layer_.remove();
-            var filteredLayers_1 = [];
-            this._layers.forEach(function (_a) {
-                var feature = _a.feature, layer = _a.layer;
-                if (layer) {
-                    var ok = fun
-                        ? fun(__assign({ target: _this, feature: feature, layer: layer }, createFeaturePositionOptions(feature)))
-                        : true;
-                    if (ok) {
-                        layer_.addLayer(layer);
-                        filteredLayers_1.push(__assign({ target: _this, feature: feature, layer: layer }, createFeaturePositionOptions(feature)));
-                    }
-                    else {
-                        layer_.removeLayer(layer);
-                    }
-                }
-            });
-            this._filteredLayers = filteredLayers_1;
-            layer_.addTo(map);
-        }
-        return this._filteredLayers;
-    };
-    GeoJsonAdapter.prototype.cleanFilter = function () {
-        this.filter();
-    };
-    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));
-        });
-    };
-    GeoJsonAdapter.prototype.clearLayer = function (cb) {
-        this.unselect();
-        var layer_ = this.layer;
-        if (layer_) {
-            if (cb) {
-                for (var fry = this._layers.length; fry--;) {
-                    var def = this._layers[fry];
-                    if (def) {
-                        var feature = def.feature, layer = def.layer;
-                        if (feature && layer) {
-                            var exist = cb(feature);
-                            if (exist) {
-                                layer_.removeLayer(layer);
-                                this._layers.splice(fry, 1);
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                layer_.clearLayers();
-                this._layers = [];
-            }
-        }
-    };
-    GeoJsonAdapter.prototype.setData = function (data) {
-        this.clearLayer();
-        this.addData(data);
-    };
-    GeoJsonAdapter.prototype.addData = function (data) {
-        var options = this.options;
-        var geoJsonOptions;
-        if (options) {
-            if (data) {
-                var type = void 0;
-                if (!options.type) {
-                    var detectedType = detectType(data);
-                    type = typeAlias[detectedType];
-                }
-                else {
-                    type = options.type;
-                }
-                if (this.type && this.type !== type) {
-                    console.warn('no other data type than layer can be added');
-                    return;
-                }
-                this.type = type;
-                data = filterGeometries(data, type);
-                if (data) {
-                    geoJsonOptions = this._getGeoJsonOptions(options, type);
-                }
-            }
-            new GeoJSON(data || undefined, geoJsonOptions);
-        }
-    };
-    GeoJsonAdapter.prototype.openPopup = function (findFeatureFun, options) {
-        var _this = this;
-        if (findFeatureFun) {
-            var def = this._layers.filter(findFeatureFun);
-            def.forEach(function (x) {
-                _this._openPopup(x, options, 'api');
-            });
-        }
-    };
-    GeoJsonAdapter.prototype.closePopup = function (findFeatureFun) {
-        var _this = this;
-        var popupToClose = findFeatureFun
-            ? this._openedPopup.filter(function (x) { return findFeatureFun(x[2]); })
-            : this._openedPopup;
-        popupToClose.forEach(function (x) {
-            _this._removePopup(x[0]);
-        });
-    };
-    GeoJsonAdapter.prototype.updateTooltip = function (layerDef) {
-        var _this = this;
-        if (layerDef) {
-            this._updateTooltip(layerDef);
-        }
-        else {
-            this.getLayers().forEach(function (x) {
-                return _this._updateTooltip({ feature: x.feature, layer: x.layer });
-            });
-        }
-    };
-    /** @deprecated use {@link GeoJsonAdapter.getBounds} instead */
-    GeoJsonAdapter.prototype.getExtent = function () {
-        return this.getBounds();
-    };
-    GeoJsonAdapter.prototype.getBounds = function () {
-        if (this.layer) {
-            var bounds = this.layer.getBounds();
-            if (bounds.isValid()) {
-                return boundsToArray(bounds);
-            }
-        }
-    };
-    GeoJsonAdapter.prototype.setOpacity = function (value) {
-        this.options.opacity = value;
-        this.setPaint(this.paint);
-        this.setSelectedPaint(this.selectedPaint);
-    };
-    GeoJsonAdapter.prototype.setPaint = function (paint) {
-        if (paint) {
-            this.paint = paint;
-            for (var _i = 0, _a = this._layers; _i < _a.length; _i++) {
-                var l = _a[_i];
-                this._setPaint(l, paint);
-            }
-        }
-    };
-    GeoJsonAdapter.prototype.setSelectedPaint = function (paint) {
-        if (paint) {
-            this.selectedPaint = paint;
-            for (var _i = 0, _a = this._selectedLayers; _i < _a.length; _i++) {
-                var l = _a[_i];
-                this._setPaint(l, paint);
-            }
-        }
-    };
-    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);
-        }
-    };
-    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);
-        }
-    };
-    GeoJsonAdapter.prototype._updateTooltip = function (layerDef) {
-        var feature = layerDef.feature, layer = layerDef.layer;
-        if (feature && layer && feature.properties && this.options.labelField) {
-            layer.unbindTooltip();
-            var message = feature.properties[this.options.labelField];
-            if (message !== undefined) {
-                var permanent = !this.options.labelOnHover;
-                layer.bindTooltip(String(message), { permanent: permanent, sticky: false });
-            }
-        }
-    };
-    GeoJsonAdapter.prototype._openPopup = function (def, options, type, latLng) {
-        var _a, _b;
-        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*/];
-                }
-            });
-        });
-    };
-    GeoJsonAdapter.prototype._removePopup = function (popup) {
-        var _a, _b;
-        var map = this.map;
-        if (map) {
-            popup.closePopup().unbindPopup();
-            var index = this._openedPopup.findIndex(function (x) { return x[0] === popup; });
-            if (index !== -1) {
-                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;
-                if (unselectOnClose) {
-                    this._unSelectLayer(def);
-                }
-                this._openedPopup.splice(index, 1);
-            }
-        }
-    };
-    GeoJsonAdapter.prototype._setPaintEachLayer = function (paint) {
-        var _this = this;
-        this._layers.forEach(function (l) {
-            _this._setPaint(l, paint);
-        });
-    };
-    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);
-            }
-            else if (isPaint(paint)) {
-                style = paint;
-            }
-            if (style) {
-                if (this.type === 'point' && style.type === 'icon') {
-                    var marker = layer;
-                    var divIcon = this._createDivIcon(style);
-                    marker.setIcon(divIcon);
-                }
-                else if ('setStyle' in layer) {
-                    layer.setStyle(this._preparePaint(style));
-                }
-            }
-        }
-    };
-    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;
-            // }
-            var paintAliases = [
-                // ['color', 'color'],
-                ['color', 'strokeColor'],
-                ['opacity', 'strokeOpacity'],
-                ['stroke', 'stroke'],
-                ['fillColor', 'fillColor'],
-                ['fillOpacity', 'fillOpacity'],
-                ['fill', 'fill'],
-                ['weight', 'weight'],
-            ];
-            var aliases = this.type === 'line'
-                ? [
-                    ['color', 'strokeColor'],
-                    ['opacity', 'strokeOpacity'],
-                    ['weight', 'weight'],
-                ]
-                : paintAliases;
-            var readyPaint = {};
-            if ('radius' in paint && typeof paint.radius === 'number') {
-                readyPaint.radius = paint.radius;
-            }
-            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;
-                }
-                if (paintProp !== undefined) {
-                    Object.defineProperty(readyPaint, to, {
-                        enumerable: true,
-                        value: paintProp,
-                    });
-                }
-            }
-            return readyPaint;
-        }
-        return PAINT;
-    };
-    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 = function (feature, latLng) {
-                    var iconOpt = paint(feature);
-                    var pointToLayer = _this._createPaintToLayer(iconOpt);
-                    return pointToLayer(feature, latLng);
-                };
-            }
-            else {
-                lopt = {
-                    style: function (feature) {
-                        if (feature) {
-                            return _this._preparePaint(__assign(__assign({}, PAINT), paint(feature)));
-                        }
-                        else {
-                            return _this._preparePaint(__assign(__assign({}, PAINT), { type: 'path' }));
-                        }
-                    },
-                };
-            }
-        }
-        else {
-            lopt = this._createPaintOptions(paint, type);
-        }
-        lopt.onEachFeature = function (feature, layer) {
-            _this._onEachFeature(feature, layer);
-        };
-        return lopt;
-    };
-    GeoJsonAdapter.prototype._onEachFeature = function (feature, layer) {
-        var _this = this;
-        var layer_ = this.layer;
-        if (layer_) {
-            var def_2 = __assign({ target: this, feature: feature, layer: layer }, createFeaturePositionOptions(feature));
-            // @ts-ignore
-            layer.options.pane = this.pane;
-            this._layers.push(def_2);
-            var ok = true;
-            if (this._filterFun) {
-                ok = this._filterFun(def_2);
-            }
-            if (ok) {
-                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', function () {
-                            _this._selectLayer(def_2, 'hover');
-                        });
-                        layer.on('mouseout', function () {
-                            _this._unSelectLayer(def_2);
-                        });
-                    }
-                    else {
-                        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(function () {
-                    if (popup_1) {
-                        _this._openPopup(__assign({ target: _this, layer: layer, feature: feature }, createFeaturePositionOptions(feature)), popupOptions_1, 'api');
-                    }
-                    _this._updateTooltip({ layer: layer, feature: feature });
-                });
-            }
-        }
-    };
-    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
-        var onClick_ = onClick || onLayerClick;
-        if (onClick_) {
-            layer.on('click', function (e) {
-                var selected = !!_this._getSelected(layer);
-                onClick_(__assign({ selected: selected }, _this._createMouseEvent(e)));
-            }, this);
-        }
-        if (onMouseOut) {
-            layer.on('mouseout', function (e) {
-                onMouseOut(_this._createMouseEvent(e));
-            }, this);
-        }
-        if (onMouseOver) {
-            layer.on('mouseover', function (e) {
-                onMouseOver(_this._createMouseEvent(e));
-            }, this);
-        }
-    };
-    GeoJsonAdapter.prototype._createMouseEvent = function (source) {
-        return createMouseEvent({
-            layer: this,
-            source: source,
-        });
-    };
-    GeoJsonAdapter.prototype._getSelected = function (layer) {
-        return this._selectedLayers.find(function (x) { return x.layer === layer; });
-    };
-    GeoJsonAdapter.prototype._selectOnLayerClick = function (e) {
-        DomEvent.stopPropagation(e);
-        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);
-            }
-        }
-        else {
-            this._selectLayer(def, 'click', e.latlng);
-        }
-    };
-    GeoJsonAdapter.prototype._selectLayer = function (def, type, latlng) {
-        var _this = this;
-        var multiselect = this.options.multiselect;
-        if (!multiselect) {
-            // To unselect layer on another layer click
-            this.map._addUnselectCb(function () {
-                _this._unSelectLayer(def);
-            });
-            this._selectedLayers.forEach(function (x) { return _this._unSelectLayer(x); });
-        }
-        this._selectedLayers.push(def);
-        this.selected = true;
-        var _a = this.options, selectedPaint = _a.selectedPaint, popupOnSelect = _a.popupOnSelect, popupOptions = _a.popupOptions;
-        if (selectedPaint && def.layer) {
-            this._setPaint(def, selectedPaint);
-        }
-        if (popupOnSelect) {
-            this._openPopup(def, popupOptions, type, latlng);
-        }
-        if (this.options.onSelect) {
-            var features = def.feature ? [def.feature] : [];
-            this.options.onSelect(__assign({ type: type, layer: this, features: features }, createFeaturePositionOptions(features)));
-        }
-    };
-    GeoJsonAdapter.prototype._unSelectLayer = function (def) {
-        var index = this._selectedLayers.indexOf(def);
-        if (index !== -1) {
-            this._selectedLayers.splice(index, 1);
-            if (this.options) {
-                if (this.options.paint) {
-                    this._setPaint(def, this.options.paint);
-                }
-                if (this.options.popupOnSelect && def.layer) {
-                    this._removePopup(def.layer);
-                }
-            }
-        }
-        this.selected = this._selectedLayers.length > 0;
-    };
-    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') {
-                var iconClassName = icon.className;
-                var html = icon.html;
-                if (iconClassName || html) {
-                    return function (geoJsonPoint, latlng) {
-                        var divIcon = _this._createDivIcon(icon);
-                        return new Marker(latlng, { icon: divIcon });
-                    };
-                }
-            }
-            else if (icon.type === 'pin') {
-                return function (geoJsonPoint, latlng) {
-                    // const divIcon = this.createDivIcon(icon);
-                    return new Marker(latlng);
-                };
-            }
-        }
-        return function (geoJsonPoint, latlng) {
-            var p = PAINT;
-            return new CircleMarker(latlng, _this._preparePaint(__assign(__assign({}, p), icon)));
-        };
-    };
-    GeoJsonAdapter.prototype._createPaintOptions = function (paintOptions, type) {
-        var geoJsonOptions = {};
-        var paint = (paintOptions && this._preparePaint(paintOptions)) || {};
-        if (paintOptions) {
-            geoJsonOptions.style = function () {
-                return paint;
-            };
-        }
-        if (type === 'point') {
-            geoJsonOptions.pointToLayer = this._createPaintToLayer(paintOptions);
-        }
-        else if (type === 'line') {
-            paint.stroke = true;
-        }
-        return geoJsonOptions;
-    };
-    GeoJsonAdapter.prototype._addMapClickListener = function () {
-        var map = this.map;
-        if (map) {
-            var unselectOnClick = this.options.unselectOnClick;
-            var uoc = unselectOnClick !== null && unselectOnClick !== void 0 ? unselectOnClick : true;
-            if (uoc) {
-                map.on('click', this.$unselect);
-            }
-        }
-    };
-    GeoJsonAdapter.prototype._removeMapClickListener = function () {
-        this.map.off('zoomend', this.$updateTooltip);
-        this.map.off('moveend', this.$updateTooltip);
-        this.map.off('click', this.$unselect);
-    };
-    GeoJsonAdapter.prototype._addMapListener = function () {
-        var map = this.map;
-        if (map) {
-            var _a = this.options, labelField = _a.labelField, labelOnHover = _a.labelOnHover;
-            this._addMapClickListener();
-            if (labelField && !labelOnHover) {
-                map.on('zoomend', this.$updateTooltip);
-                map.on('moveend', this.$updateTooltip);
-            }
-        }
-    };
-    GeoJsonAdapter.prototype._removeMapListener = function () {
-        this._removeMapClickListener();
-        this.map.off('zoomend', this.$updateTooltip);
-        this.map.off('moveend', this.$updateTooltip);
-    };
-    return GeoJsonAdapter;
-}(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();
+        }, 300);
+        this.$unselect = () => {
+            this.unselect();
+        };
+    }
+    addLayer(options) {
+        Object.assign(this.options, options);
+        this.paint = options.paint;
+        this.layer = new FeatureGroup([], {
+            ...options.nativeOptions,
+            pane: this.pane,
+        });
+        this.selectedPaint = options.selectedPaint;
+        options.paint = this.paint;
+        if (options.data) {
+            this.addData(options.data);
+        }
+        this._addMapListener();
+        return this.layer;
+    }
+    beforeRemove() {
+        this._removeMapListener();
+    }
+    select(findFeatureFun) {
+        this.unselect();
+        if (findFeatureFun) {
+            const def = this._layers.filter(findFeatureFun);
+            for (const x of def) {
+                this._selectLayer(x, 'api');
+            }
+        }
+        else if (!this.selected) {
+            this.selected = true;
+            if (this.selectedPaint) {
+                this._setPaintEachLayer(this.selectedPaint);
+            }
+        }
+    }
+    unselect(findFeatureFun) {
+        if (findFeatureFun) {
+            const feature = this._layers.filter(findFeatureFun);
+            feature.forEach((x) => {
+                this._unSelectLayer(x);
+            });
+        }
+        else if (this.selected) {
+            for (const p of this._openedPopup) {
+                this._removePopup(p[0]);
+            }
+            if (this.paint) {
+                this._setPaintEachLayer(this.paint);
+            }
+            this._selectedLayers.length = 0;
+            this.selected = false;
+        }
+    }
+    getSelected() {
+        return this._selectedLayers.map((x) => {
+            return {
+                target: this,
+                feature: x.feature,
+                layer: x,
+                ...createFeaturePositionOptions(x.feature),
+            };
+        });
+    }
+    getFiltered() {
+        return this._filteredLayers;
+    }
+    filter(fun) {
+        // Some optimization
+        this._filterFun = fun;
+        const layer_ = this.layer;
+        const map = layer_ && layer_._map;
+        if (layer_ && map) {
+            layer_.remove();
+            const filteredLayers = [];
+            this._layers.forEach(({ feature, layer }) => {
+                if (layer) {
+                    const ok = fun
+                        ? fun({
+                            target: this,
+                            feature,
+                            layer,
+                            ...createFeaturePositionOptions(feature),
+                        })
+                        : true;
+                    if (ok) {
+                        layer_.addLayer(layer);
+                        filteredLayers.push({
+                            target: this,
+                            feature,
+                            layer,
+                            ...createFeaturePositionOptions(feature),
+                        });
+                    }
+                    else {
+                        layer_.removeLayer(layer);
+                    }
+                }
+            });
+            this._filteredLayers = filteredLayers;
+            layer_.addTo(map);
+        }
+        return this._filteredLayers;
+    }
+    cleanFilter() {
+        this.filter();
+    }
+    getLayers() {
+        return this._layers.map(({ layer, feature }) => {
+            const visible = layer && !!layer._map;
+            return {
+                feature,
+                layer,
+                visible,
+                target: this,
+                ...createFeaturePositionOptions(feature),
+            };
+        });
+    }
+    clearLayer(cb) {
+        this.unselect();
+        const layer_ = this.layer;
+        if (layer_) {
+            if (cb) {
+                for (let fry = this._layers.length; fry--;) {
+                    const def = this._layers[fry];
+                    if (def) {
+                        const { feature, layer } = def;
+                        if (feature && layer) {
+                            const exist = cb(feature);
+                            if (exist) {
+                                layer_.removeLayer(layer);
+                                this._layers.splice(fry, 1);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                layer_.clearLayers();
+                this._layers = [];
+            }
+        }
+    }
+    setData(data) {
+        this.clearLayer();
+        this.addData(data);
+    }
+    addData(data) {
+        const options = this.options;
+        let geoJsonOptions;
+        if (options) {
+            if (data) {
+                let type;
+                if (!options.type) {
+                    const detectedType = detectType(data);
+                    type = typeAlias[detectedType];
+                }
+                else {
+                    type = options.type;
+                }
+                if (this.type && this.type !== type) {
+                    console.warn('no other data type than layer can be added');
+                    return;
+                }
+                this.type = type;
+                data = filterGeometries(data, type);
+                if (data) {
+                    geoJsonOptions = this._getGeoJsonOptions(options, type);
+                }
+            }
+            new GeoJSON(data || undefined, geoJsonOptions);
+        }
+    }
+    openPopup(findFeatureFun, options) {
+        if (findFeatureFun) {
+            const def = this._layers.filter(findFeatureFun);
+            def.forEach((x) => {
+                this._openPopup(x, options, 'api');
+            });
+        }
+    }
+    closePopup(findFeatureFun) {
+        const popupToClose = findFeatureFun
+            ? this._openedPopup.filter((x) => findFeatureFun(x[2]))
+            : this._openedPopup;
+        popupToClose.forEach((x) => {
+            this._removePopup(x[0]);
+        });
+    }
+    updateTooltip(layerDef) {
+        if (layerDef) {
+            this._updateTooltip(layerDef);
+        }
+        else {
+            this.getLayers().forEach((x) => this._updateTooltip({ feature: x.feature, layer: x.layer }));
+        }
+    }
+    /** @deprecated use {@link GeoJsonAdapter.getBounds} instead */
+    getExtent() {
+        return this.getBounds();
+    }
+    getBounds() {
+        if (this.layer) {
+            const bounds = this.layer.getBounds();
+            if (bounds.isValid()) {
+                return boundsToArray(bounds);
+            }
+        }
+    }
+    setOpacity(value) {
+        this.options.opacity = value;
+        this.setPaint(this.paint);
+        this.setSelectedPaint(this.selectedPaint);
+    }
+    setPaint(paint) {
+        if (paint) {
+            this.paint = paint;
+            for (const l of this._layers) {
+                this._setPaint(l, paint);
+            }
+        }
+    }
+    setSelectedPaint(paint) {
+        if (paint) {
+            this.selectedPaint = paint;
+            for (const l of this._selectedLayers) {
+                this._setPaint(l, paint);
+            }
+        }
+    }
+    updatePaint(paint) {
+        this.paint = { ...this.paint, ...paint };
+        for (const l of this._layers) {
+            this._setPaint(l, this.paint);
+        }
+    }
+    updateSelectedPaint(paint) {
+        this.selectedPaint = { ...this.selectedPaint, ...paint };
+        for (const l of this._selectedLayers) {
+            this._setPaint(l, this.selectedPaint);
+        }
+    }
+    _updateTooltip(layerDef) {
+        const { feature, layer } = layerDef;
+        if (feature && layer && feature.properties && this.options.labelField) {
+            layer.unbindTooltip();
+            const message = feature.properties[this.options.labelField];
+            if (message !== undefined) {
+                const permanent = !this.options.labelOnHover;
+                layer.bindTooltip(String(message), { permanent, sticky: false });
+            }
+        }
+    }
+    async _openPopup(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),
+            });
+        }
+        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) {
+        var _a, _b;
+        const map = this.map;
+        if (map) {
+            popup.closePopup().unbindPopup();
+            const index = this._openedPopup.findIndex((x) => 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) {
+                    h(def);
+                }
+                closeHandlers.length = 0;
+                if (unselectOnClose) {
+                    this._unSelectLayer(def);
+                }
+                this._openedPopup.splice(index, 1);
+            }
+        }
+    }
+    _setPaintEachLayer(paint) {
+        this._layers.forEach((l) => {
+            this._setPaint(l, paint);
+        });
+    }
+    _setPaint(def, paint) {
+        let style = undefined;
+        const { layer, feature } = def;
+        if (layer && feature) {
+            if (isPaintCallback(paint)) {
+                style = paint(feature);
+            }
+            else if (isPaint(paint)) {
+                style = paint;
+            }
+            if (style) {
+                if (this.type === 'point' && style.type === 'icon') {
+                    const marker = layer;
+                    const divIcon = this._createDivIcon(style);
+                    marker.setIcon(divIcon);
+                }
+                else if ('setStyle' in layer) {
+                    layer.setStyle(this._preparePaint(style));
+                }
+            }
+        }
+    }
+    _preparePaint(paint) {
+        if (paint.type !== 'get-paint') {
+            // const path: CircleMarkerOptions | PathOptions = paint as CircleMarkerOptions | PathOptions;
+            // if (path.opacity) {
+            //   path.fillOpacity = path.opacity;
+            // }
+            const paintAliases = [
+                // ['color', 'color'],
+                ['color', 'strokeColor'],
+                ['opacity', 'strokeOpacity'],
+                ['stroke', 'stroke'],
+                ['fillColor', 'fillColor'],
+                ['fillOpacity', 'fillOpacity'],
+                ['fill', 'fill'],
+                ['weight', 'weight'],
+            ];
+            const aliases = this.type === 'line'
+                ? [
+                    ['color', 'strokeColor'],
+                    ['opacity', 'strokeOpacity'],
+                    ['weight', 'weight'],
+                ]
+                : paintAliases;
+            const readyPaint = {};
+            if ('radius' in paint && typeof paint.radius === 'number') {
+                readyPaint.radius = paint.radius;
+            }
+            for (const [to, from] of aliases) {
+                let paintProp = paint[from];
+                if (defined(this.options.opacity) &&
+                    from.toLowerCase().indexOf('opacity') !== -1) {
+                    paintProp = Number(paintProp) * this.options.opacity;
+                }
+                if (paintProp !== undefined) {
+                    Object.defineProperty(readyPaint, to, {
+                        enumerable: true,
+                        value: paintProp,
+                    });
+                }
+            }
+            return readyPaint;
+        }
+        return PAINT;
+    }
+    _getGeoJsonOptions(options, type) {
+        const paint = options.paint;
+        let 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);
+                    return pointToLayer(feature, latLng);
+                };
+            }
+            else {
+                lopt = {
+                    style: (feature) => {
+                        if (feature) {
+                            return this._preparePaint({ ...PAINT, ...paint(feature) });
+                        }
+                        else {
+                            return this._preparePaint({ ...PAINT, type: 'path' });
+                        }
+                    },
+                };
+            }
+        }
+        else {
+            lopt = this._createPaintOptions(paint, type);
+        }
+        lopt.onEachFeature = (feature, layer) => {
+            this._onEachFeature(feature, layer);
+        };
+        return lopt;
+    }
+    _onEachFeature(feature, layer) {
+        const layer_ = this.layer;
+        if (layer_) {
+            const def = {
+                target: this,
+                feature,
+                layer,
+                ...createFeaturePositionOptions(feature),
+            };
+            // @ts-ignore
+            layer.options.pane = this.pane;
+            this._layers.push(def);
+            let ok = true;
+            if (this._filterFun) {
+                ok = this._filterFun(def);
+            }
+            if (ok) {
+                const { popup, popupOptions, selectable, interactive, selectOnHover } = this.options;
+                // @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('mouseout', () => {
+                            this._unSelectLayer(def);
+                        });
+                    }
+                    else {
+                        layer.on('click', (e) => 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');
+                    }
+                    this._updateTooltip({ layer, feature });
+                });
+            }
+        }
+    }
+    _handleMouseEvents(layer) {
+        const { onClick, onLayerClick, onMouseOut, onMouseOver } = this.options;
+        // TODO: remove backward compatibility for onLayerClick
+        const onClick_ = onClick || onLayerClick;
+        if (onClick_) {
+            layer.on('click', (e) => {
+                const selected = !!this._getSelected(layer);
+                onClick_({
+                    selected,
+                    ...this._createMouseEvent(e),
+                });
+            }, this);
+        }
+        if (onMouseOut) {
+            layer.on('mouseout', (e) => {
+                onMouseOut(this._createMouseEvent(e));
+            }, this);
+        }
+        if (onMouseOver) {
+            layer.on('mouseover', (e) => {
+                onMouseOver(this._createMouseEvent(e));
+            }, this);
+        }
+    }
+    _createMouseEvent(source) {
+        return createMouseEvent({
+            layer: this,
+            source: source,
+        });
+    }
+    _getSelected(layer) {
+        return this._selectedLayers.find((x) => x.layer === layer);
+    }
+    _selectOnLayerClick(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);
+        if (isSelected) {
+            if (this.options && this.options.unselectOnSecondClick) {
+                this._unSelectLayer(isSelected);
+            }
+        }
+        else {
+            this._selectLayer(def, 'click', e.latlng);
+        }
+    }
+    _selectLayer(def, type, latlng) {
+        const { multiselect } = this.options;
+        if (!multiselect) {
+            // To unselect layer on another layer click
+            this.map._addUnselectCb(() => {
+                this._unSelectLayer(def);
+            });
+            this._selectedLayers.forEach((x) => this._unSelectLayer(x));
+        }
+        this._selectedLayers.push(def);
+        this.selected = true;
+        const { selectedPaint, popupOnSelect, popupOptions } = this.options;
+        if (selectedPaint && def.layer) {
+            this._setPaint(def, selectedPaint);
+        }
+        if (popupOnSelect) {
+            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),
+            });
+        }
+    }
+    _unSelectLayer(def) {
+        const index = this._selectedLayers.indexOf(def);
+        if (index !== -1) {
+            this._selectedLayers.splice(index, 1);
+            if (this.options) {
+                if (this.options.paint) {
+                    this._setPaint(def, this.options.paint);
+                }
+                if (this.options.popupOnSelect && def.layer) {
+                    this._removePopup(def.layer);
+                }
+            }
+        }
+        this.selected = this._selectedLayers.length > 0;
+    }
+    _createDivIcon(icon) {
+        const { ...toLIconOpt } = icon;
+        return new DivIcon({ className: '', ...toLIconOpt });
+    }
+    _createPaintToLayer(icon) {
+        if (icon && icon.type) {
+            if (icon.type === 'icon') {
+                const iconClassName = icon.className;
+                const html = icon.html;
+                if (iconClassName || html) {
+                    return (geoJsonPoint, latlng) => {
+                        const divIcon = this._createDivIcon(icon);
+                        return new Marker(latlng, { icon: divIcon });
+                    };
+                }
+            }
+            else if (icon.type === 'pin') {
+                return (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 }));
+        };
+    }
+    _createPaintOptions(paintOptions, type) {
+        const geoJsonOptions = {};
+        const paint = (paintOptions && this._preparePaint(paintOptions)) || {};
+        if (paintOptions) {
+            geoJsonOptions.style = () => {
+                return paint;
+            };
+        }
+        if (type === 'point') {
+            geoJsonOptions.pointToLayer = this._createPaintToLayer(paintOptions);
+        }
+        else if (type === 'line') {
+            paint.stroke = true;
+        }
+        return geoJsonOptions;
+    }
+    _addMapClickListener() {
+        const map = this.map;
+        if (map) {
+            const { unselectOnClick } = this.options;
+            const uoc = unselectOnClick !== null && unselectOnClick !== void 0 ? unselectOnClick : true;
+            if (uoc) {
+                map.on('click', this.$unselect);
+            }
+        }
+    }
+    _removeMapClickListener() {
+        this.map.off('zoomend', this.$updateTooltip);
+        this.map.off('moveend', this.$updateTooltip);
+        this.map.off('click', this.$unselect);
+    }
+    _addMapListener() {
+        const map = this.map;
+        if (map) {
+            const { labelField, labelOnHover } = this.options;
+            this._addMapClickListener();
+            if (labelField && !labelOnHover) {
+                map.on('zoomend', this.$updateTooltip);
+                map.on('moveend', this.$updateTooltip);
+            }
+        }
+    }
+    _removeMapListener() {
+        this._removeMapClickListener();
+        this.map.off('zoomend', this.$updateTooltip);
+        this.map.off('moveend', this.$updateTooltip);
+    }
+}
 
-function callAjax(src, callback, headers) {
-    var xhr = new XMLHttpRequest();
-    xhr.open('GET', src);
-    xhr.responseType = 'arraybuffer';
-    for (var h in headers) {
-        xhr.setRequestHeader(h, headers[h]);
-    }
-    xhr.onload = function () {
-        var arrayBufferView = new Uint8Array(this.response);
-        var blob = new Blob([arrayBufferView], { type: 'image/png' });
-        // @ts-ignore for typedoc
-        var urlCreator = window.URL || window.webkitURL;
-        var imageUrl = urlCreator.createObjectURL(blob);
-        callback(imageUrl);
-    };
-    xhr.send();
-    return function () {
-        xhr.abort();
-    };
+function callAjax(src, callback, headers) {
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', src);
+    xhr.responseType = 'arraybuffer';
+    for (const 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' });
+        // @ts-ignore for typedoc
+        const urlCreator = window.URL || window.webkitURL;
+        const imageUrl = urlCreator.createObjectURL(blob);
+        callback(imageUrl);
+    };
+    xhr.send();
+    return () => {
+        xhr.abort();
+    };
 }
 
-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(function (x) { return x(); });
-            this._abort = [];
-        }
-    };
-    ImageOverlay.prototype._initImage = function () {
-        // @ts-ignore
-        _super.prototype._initImage.call(this);
-        // @ts-ignore
-        var headers = this.options.headers;
-        if (headers) {
-            // @ts-ignore
-            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));
+class ImageOverlay extends ImageOverlay$1 {
+    constructor(imageUrl, bounds, options) {
+        super(imageUrl, bounds, options);
+        this._abort = [];
+    }
+    cancelLoad() {
+        if (this._abort) {
+            this._abort.forEach((x) => x());
+            this._abort = [];
+        }
+    }
+    _initImage() {
+        // @ts-ignore
+        super._initImage();
+        // @ts-ignore
+        const 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;
+            }, headers));
+        }
+    }
+}
 
-/*!
- * leaflet.wms.js
- * A collection of Leaflet utilities for working with Web Mapping services.
- * (c) 2014-2016, Houston Engineering, Inc.
- * MIT License
- */
-/*
- * Overlay:
- * "Single Tile" WMS image overlay that updates with map changes.
- * Portions of wms.Overlay are directly extracted from L.TileLayer.WMS.
- * See Leaflet license.
- */
-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',
-            layers: '',
-            styles: '',
-            format: 'image/jpeg',
-            transparent: false,
-        };
-        _this.options = {
-            crs: null,
-            uppercase: false,
-            attribution: '',
-            opacity: 1,
-            isBack: false,
-            minZoom: 0,
-            pane: 'tilePane',
-            headers: null,
-            viewPortBuffer: 0,
-            setViewDelay: 100,
-        };
-        _this._url = url;
-        // Move WMS parameters to params object
-        var params = {};
-        var opts = {};
-        var opt;
-        for (opt in 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);
-        return _this;
-    }
-    ImageLayer.prototype.setParams = function (params) {
-        Util.extend(this.wmsParams, params);
-        this.update();
-    };
-    ImageLayer.prototype.getAttribution = function () {
-        return this.options.attribution || '';
-    };
-    ImageLayer.prototype.onAdd = function () {
-        this.update();
-        return this;
-    };
-    ImageLayer.prototype.onRemove = function (map) {
-        if (this._currentOverlay) {
-            this._currentOverlay.cancelLoad();
-            map.removeLayer(this._currentOverlay);
-            delete this._currentOverlay;
-        }
-        if (this._currentUrl) {
-            delete this._currentUrl;
-        }
-        return this;
-    };
-    ImageLayer.prototype.getEvents = function () {
-        return {
-            moveend: debounce$1(this.update, this.options.setViewDelay),
-        };
-    };
-    ImageLayer.prototype.update = function () {
-        var _this = this;
-        if (!this._map) {
-            return;
-        }
-        // Determine image URL and whether it has changed since last update
-        this.updateWmsParams();
-        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)
-        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,
-        });
-        overlay.addTo(this._map);
-        if (this._currentOverlay) {
-            this._currentOverlay.cancelLoad();
-        }
-        overlay.once('load', function () {
-            if (!_this._map) {
-                return;
-            }
-            // @ts-ignore
-            if (overlay._url !== _this._currentUrl) {
-                _this._map.removeLayer(overlay);
-                return;
-            }
-            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) {
-                overlay.bringToBack();
-            }
-            if (_this.options.isBack === false) {
-                overlay.bringToFront();
-            }
-            if (_this.options.zIndex !== undefined) {
-                overlay.setZIndex(_this.options.zIndex);
-            }
-        }, this);
-        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);
-        }
-    };
-    ImageLayer.prototype.setOpacity = function (opacity) {
-        this.options.opacity = opacity;
-        if (this._currentOverlay) {
-            this._currentOverlay.setOpacity(opacity);
-        }
-    };
-    ImageLayer.prototype.bringToBack = function () {
-        this.options.isBack = true;
-        if (this._currentOverlay) {
-            this._currentOverlay.bringToBack();
-        }
-    };
-    ImageLayer.prototype.bringToFront = function () {
-        this.options.isBack = false;
-        if (this._currentOverlay) {
-            this._currentOverlay.bringToFront();
-        }
-    };
-    ImageLayer.prototype.setZIndex = function (zIndex) {
-        this.options.zIndex = zIndex;
-        if (this._currentOverlay) {
-            this._currentOverlay.setZIndex(zIndex);
-        }
-    };
-    // See L.TileLayer.WMS: onAdd() & getTileUrl()
-    ImageLayer.prototype.updateWmsParams = function (map) {
-        if (!map) {
-            map = this._map;
-        }
-        // Compute WMS options
-        var viewPortBuffer = this.options.viewPortBuffer || 0;
-        var bounds = map.getBounds().pad(viewPortBuffer);
-        var size = map.getSize();
-        if (this.options.viewPortBuffer !== 0) {
-            var factor = viewPortBuffer + 1;
-            size.x = Math.ceil(size.x * factor);
-            size.y = Math.ceil(size.y * factor);
-        }
-        var wmsVersion = parseFloat(this.wmsParams.version);
-        var crs = this.options.crs || map.options.crs;
-        var projectionKey = wmsVersion >= 1.3 ? 'crs' : 'srs';
-        if (crs) {
-            var nw = crs.project(bounds.getNorthWest());
-            var se = crs.project(bounds.getSouthEast());
-            // Assemble WMS parameter string
-            var params = {
-                width: size.x,
-                height: size.y,
-            };
-            params[projectionKey] = crs.code;
-            params.bbox = (wmsVersion >= 1.3 && crs === CRS.EPSG4326
-                ? [se.y, nw.x, nw.y, se.x]
-                : [nw.x, se.y, se.x, nw.y]).join(',');
-            Util.extend(this.wmsParams, params);
-        }
-    };
-    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));
+/*!
+ * leaflet.wms.js
+ * A collection of Leaflet utilities for working with Web Mapping services.
+ * (c) 2014-2016, Houston Engineering, Inc.
+ * MIT License
+ */
+/*
+ * Overlay:
+ * "Single Tile" WMS image overlay that updates with map changes.
+ * 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 = {
+            service: 'WMS',
+            request: 'GetMap',
+            version: '1.1.1',
+            layers: '',
+            styles: '',
+            format: 'image/jpeg',
+            transparent: false,
+        };
+        this.options = {
+            crs: null,
+            uppercase: false,
+            attribution: '',
+            opacity: 1,
+            isBack: false,
+            minZoom: 0,
+            pane: 'tilePane',
+            headers: null,
+            viewPortBuffer: 0,
+            setViewDelay: 100,
+        };
+        this._url = url;
+        // Move WMS parameters to params object
+        const params = {};
+        const opts = {};
+        let opt;
+        for (opt in 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);
+    }
+    setParams(params) {
+        Util.extend(this.wmsParams, params);
+        this.update();
+    }
+    getAttribution() {
+        return this.options.attribution || '';
+    }
+    onAdd() {
+        this.update();
+        return this;
+    }
+    onRemove(map) {
+        if (this._currentOverlay) {
+            this._currentOverlay.cancelLoad();
+            map.removeLayer(this._currentOverlay);
+            delete this._currentOverlay;
+        }
+        if (this._currentUrl) {
+            delete this._currentUrl;
+        }
+        return this;
+    }
+    getEvents() {
+        return {
+            moveend: debounce$1(this.update, this.options.setViewDelay),
+        };
+    }
+    update() {
+        if (!this._map) {
+            return;
+        }
+        // Determine image URL and whether it has changed since last update
+        this.updateWmsParams();
+        const 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, {
+            opacity: 0,
+            pane: this.options.pane,
+            headers: this.options.headers,
+        });
+        overlay.addTo(this._map);
+        if (this._currentOverlay) {
+            this._currentOverlay.cancelLoad();
+        }
+        overlay.once('load', () => {
+            if (!this._map) {
+                return;
+            }
+            // @ts-ignore
+            if (overlay._url !== this._currentUrl) {
+                this._map.removeLayer(overlay);
+                return;
+            }
+            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) {
+                overlay.bringToBack();
+            }
+            if (this.options.isBack === false) {
+                overlay.bringToFront();
+            }
+            if (this.options.zIndex !== undefined) {
+                overlay.setZIndex(this.options.zIndex);
+            }
+        }, this);
+        const { minZoom, maxZoom } = this.options;
+        if ((minZoom && this._map.getZoom() < minZoom) ||
+            (maxZoom && this._map.getZoom() > maxZoom)) {
+            this._map.removeLayer(overlay);
+        }
+    }
+    setOpacity(opacity) {
+        this.options.opacity = opacity;
+        if (this._currentOverlay) {
+            this._currentOverlay.setOpacity(opacity);
+        }
+    }
+    bringToBack() {
+        this.options.isBack = true;
+        if (this._currentOverlay) {
+            this._currentOverlay.bringToBack();
+        }
+    }
+    bringToFront() {
+        this.options.isBack = false;
+        if (this._currentOverlay) {
+            this._currentOverlay.bringToFront();
+        }
+    }
+    setZIndex(zIndex) {
+        this.options.zIndex = zIndex;
+        if (this._currentOverlay) {
+            this._currentOverlay.setZIndex(zIndex);
+        }
+    }
+    // See L.TileLayer.WMS: onAdd() & getTileUrl()
+    updateWmsParams(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();
+        if (this.options.viewPortBuffer !== 0) {
+            const 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';
+        if (crs) {
+            const nw = crs.project(bounds.getNorthWest());
+            const se = crs.project(bounds.getSouthEast());
+            // Assemble WMS parameter string
+            const params = {
+                width: size.x,
+                height: size.y,
+            };
+            params[projectionKey] = crs.code;
+            params.bbox = (wmsVersion >= 1.3 && crs === CRS.EPSG4326
+                ? [se.y, nw.x, nw.y, se.x]
+                : [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);
+        return this._url + pstr;
+    }
+}
 
-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 = __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_1.call(this, map);
-                    this.wmsParams = updateWmsParamsFromOpt_1(this.wmsParams);
-                };
-            }
-            return this.layer;
-        }
-    };
-    return ImageAdapter;
-}(BaseAdapter));
+class ImageAdapter extends BaseAdapter {
+    addLayer(options) {
+        const 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;
+                this.layer.updateWmsParams = function (map) {
+                    updateWmsParams.call(this, map);
+                    this.wmsParams = updateWmsParamsFromOpt(this.wmsParams);
+                };
+            }
+            return this.layer;
+        }
+    }
+}
 
-// based on https://github.com/bvaughn/debounce-decorator
-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(function () {
-            timeoutId = null;
-            cb.apply(_this, args);
-        }, wait);
-    }
-    wrapper.clear = function () {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-            timeoutId = null;
-        }
-    };
-    return wrapper;
+// based on https://github.com/bvaughn/debounce-decorator
+function debounce(cb, wait = 10) {
+    let timeoutId;
+    function wrapper(...args) {
+        wrapper.clear();
+        timeoutId = setTimeout(() => {
+            timeoutId = null;
+            cb.apply(this, args);
+        }, wait);
+    }
+    wrapper.clear = function () {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+    };
+    return wrapper;
 }
 
-function makeRemote(Base) {
-    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(function () {
-                    var _a;
-                    var a = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        a[_i] = arguments[_i];
-                    }
-                    // @ts-ignore
-                    (_a = GridLayer.prototype._update).call.apply(_a, __spreadArray([_this], a, false));
-                }, _this.options.setViewDelay);
-            }
-            return _this;
-        }
-        RemoteTileLayer.prototype.createTile = function (coords, done) {
-            // @ts-ignore
-            var url = this.getTileUrl(coords);
-            var tile = document.createElement('img');
-            tile.abort = callAjax(url, function (response) {
-                tile.src = response;
-                done(null, tile);
-            }, 
-            // @ts-ignore
-            this.options.headers);
-            if (this.options.crossOrigin || this.options.crossOrigin === '') {
-                tile.crossOrigin =
-                    this.options.crossOrigin === true ? '' : this.options.crossOrigin;
-            }
-            tile.alt = '';
-            tile.setAttribute('role', 'presentation');
-            return tile;
-        };
-        RemoteTileLayer.prototype._abortLoading = function () {
-            // @ts-ignore
-            var tiles = this._tiles;
-            // @ts-ignore
-            var tileZoom = this._tileZoom;
-            for (var i in tiles) {
-                if (tiles[i].coords.z !== tileZoom) {
-                    var tile = tiles[i].el;
-                    tile.onload = Util.falseFn;
-                    tile.onerror = Util.falseFn;
-                    if (!tile.complete) {
-                        if (tile.abort) {
-                            tile.abort();
-                        }
-                        tile.src = Util.emptyImageUrl;
-                        DomUtil.remove(tile);
-                        delete tiles[i];
-                    }
-                }
-            }
-        };
-        return RemoteTileLayer;
-    }(Base));
+function makeRemote(Base) {
+    return class RemoteTileLayer extends Base {
+        constructor(...args) {
+            super(...args);
+            if (this.options.setViewDelay) {
+                // @ts-ignore
+                this._update = debounce((...a) => {
+                    // @ts-ignore
+                    GridLayer.prototype._update.call(this, ...a);
+                }, this.options.setViewDelay);
+            }
+        }
+        createTile(coords, done) {
+            // @ts-ignore
+            const url = this.getTileUrl(coords);
+            const tile = document.createElement('img');
+            tile.abort = callAjax(url, (response) => {
+                tile.src = response;
+                done(null, tile);
+            }, 
+            // @ts-ignore
+            this.options.headers);
+            if (this.options.crossOrigin || this.options.crossOrigin === '') {
+                tile.crossOrigin =
+                    this.options.crossOrigin === true ? '' : this.options.crossOrigin;
+            }
+            tile.alt = '';
+            tile.setAttribute('role', 'presentation');
+            return tile;
+        }
+        _abortLoading() {
+            // @ts-ignore
+            const tiles = this._tiles;
+            // @ts-ignore
+            const tileZoom = this._tileZoom;
+            for (const i in tiles) {
+                if (tiles[i].coords.z !== tileZoom) {
+                    const tile = tiles[i].el;
+                    tile.onload = Util.falseFn;
+                    tile.onerror = Util.falseFn;
+                    if (!tile.complete) {
+                        if (tile.abort) {
+                            tile.abort();
+                        }
+                        tile.src = Util.emptyImageUrl;
+                        DomUtil.remove(tile);
+                        delete tiles[i];
+                    }
+                }
+            }
+        }
+    };
 }
 
-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 TileLayerBase extends TileLayer$1 {
+    constructor(urlTemplate, options) {
+        super(urlTemplate, options);
+        Object.assign(this.options, options);
+    }
+}
+const TileLayer = makeRemote(TileLayerBase);
 
-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) {
-            var url = options.url, opt = __rest(options, ["url"]);
-            if (url) {
-                var tileLayerOptions = __assign({ pane: this.pane, attribution: opt.attribution, minZoom: opt.minZoom, maxZoom: opt.maxZoom }, opt.nativeOptions);
-                if (opt.subdomains) {
-                    tileLayerOptions.subdomains = opt.subdomains;
-                }
-                var layer = void 0;
-                if (opt.headers) {
-                    layer = new TileLayer(url, __assign(__assign({}, tileLayerOptions), { headers: opt.headers, setViewDelay: opt.setViewDelay }));
-                }
-                else {
-                    layer = new TileLayer$1(url, tileLayerOptions);
-                }
-                return layer;
-            }
-        }
-    };
-    return TileAdapter;
-}(BaseAdapter));
+class TileAdapter extends BaseAdapter {
+    addLayer(options) {
+        this.options = Object.assign(this.options, options);
+        if (options) {
+            const { url, ...opt } = options;
+            if (url) {
+                const tileLayerOptions = {
+                    pane: this.pane,
+                    attribution: opt.attribution,
+                    minZoom: opt.minZoom,
+                    maxZoom: opt.maxZoom,
+                    ...opt.nativeOptions,
+                };
+                if (opt.subdomains) {
+                    tileLayerOptions.subdomains = opt.subdomains;
+                }
+                let layer;
+                if (opt.headers) {
+                    layer = new TileLayer(url, {
+                        ...tileLayerOptions,
+                        headers: opt.headers,
+                        setViewDelay: opt.setViewDelay,
+                    });
+                }
+                else {
+                    layer = new TileLayer$1(url, tileLayerOptions);
+                }
+                return layer;
+            }
+        }
+    }
+}
 
-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);
+class WmsLayerBase extends TileLayer$1.WMS {
+    constructor(urlTemplate, options) {
+        super(urlTemplate, options);
+    }
+}
+const WmsLayer = makeRemote(WmsLayerBase);
 
-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);
-        var url = options.url, opt = __rest(options, ["url"]);
-        if (url) {
-            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, __assign(__assign({}, layerOptions), { headers: opt.headers }));
-            }
-            else {
-                layer = new TileLayer$1.WMS(url, layerOptions);
-            }
-            return layer;
-        }
-    };
-    return WmsAdapter;
-}(BaseAdapter));
+class WmsAdapter extends BaseAdapter {
+    addLayer(options) {
+        Object.assign(this.options, options);
+        const { url, ...opt } = options;
+        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;
+            if (opt.headers) {
+                layer = new WmsLayer(url, { ...layerOptions, headers: opt.headers });
+            }
+            else {
+                layer = new TileLayer$1.WMS(url, layerOptions);
+            }
+            return layer;
+        }
+    }
+}
 
-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));
+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,
+        });
+    }
+}
 
-function arrayToBoundsExpression(bounds) {
-    var e = bounds;
-    // top, left, bottom, right
-    return [
-        [e[3], e[0]],
-        [e[1], e[2]],
-    ];
+function arrayToBoundsExpression(bounds) {
+    const e = bounds;
+    // top, left, bottom, right
+    return [
+        [e[3], e[0]],
+        [e[1], e[2]],
+    ];
 }
 
-var LeafletMapAdapter$1 = /** @class */ (function () {
-    function LeafletMapAdapter() {
-        this.options = { target: 'map' };
-        this.layerAdapters = LeafletMapAdapter.layerAdapters;
-        this.controlAdapters = LeafletMapAdapter.controlAdapters;
-        this.emitter = new EventEmitter();
-        this._unselectCb = [];
-        this._universalEvents = [
-            'move',
-            'zoom',
-            'zoomend',
-            'zoomstart',
-            'moveend',
-            'movestart',
-        ];
-        this._positionEvents = [
-            'mousemove',
-            'mouseout',
-            'mouseover',
-        ];
-    }
-    LeafletMapAdapter.prototype.create = function (options) {
-        var _this = this;
-        this.options = __assign({}, options);
-        if (this.options.target) {
-            var _a = this.options, zoom = _a.zoom, center = _a.center, maxZoom = _a.maxZoom, minZoom = _a.minZoom, mb = _a.maxBounds, mapAdapterOptions = _a.mapAdapterOptions;
-            this.map =
-                this.options.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
-            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();
-        }
-    };
-    LeafletMapAdapter.prototype.destroy = function () {
-        if (this.map) {
-            this.map.remove();
-        }
-        this._stopWatchSizeChangeToUpdateMinZoom();
-    };
-    LeafletMapAdapter.prototype.getContainer = function () {
-        return this.map && this.map.getContainer();
-    };
-    LeafletMapAdapter.prototype.getControlContainer = function () {
-        var controlContainer = this.map && this.map._controlContainer;
-        if (controlContainer) {
-            return controlContainer;
-        }
-        throw new Error('Leaflet Map is not initialized yet');
-    };
-    LeafletMapAdapter.prototype.setCursor = function (cursor) {
-        if (this.map) {
-            this.map.getContainer().style.cursor = cursor;
-        }
-    };
-    LeafletMapAdapter.prototype.setView = function (lngLatOrOpt, zoom) {
-        var map = this.map;
-        if (!map)
-            return;
-        if (Array.isArray(lngLatOrOpt)) {
-            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 });
-                }
-                else {
-                    this.setCenter([lng, lat]);
-                }
-            }
-        }
-        else {
-            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_1 !== undefined) {
-                    this.setZoom(zoom_1);
-                }
-                if (center) {
-                    this.setCenter(center);
-                }
-            }
-            if (bounds) {
-                this.fitBounds(bounds);
-            }
-            if (maxBounds !== undefined) {
-                if (maxBounds) {
-                    var b = arrayToBoundsExpression(maxBounds);
-                    map.setMaxBounds(b);
-                    map.setMinZoom(map.getBoundsZoom(b));
-                    this._watchSizeChangeToUpdateMinZoom(b);
-                }
-                else {
-                    // @ts-ignore `null` works for unset maxBounds, but not in typing
-                    map.setMaxBounds(null);
-                    this._stopWatchSizeChangeToUpdateMinZoom();
-                }
-            }
-            if (maxZoom !== undefined) {
-                map.setMaxZoom(maxZoom);
-            }
-            if (minZoom !== undefined) {
-                this._stopWatchSizeChangeToUpdateMinZoom();
-                map.setMinZoom(minZoom);
-            }
-        }
-    };
-    LeafletMapAdapter.prototype.setCenter = function (lngLat) {
-        var lng = lngLat[0], lat = lngLat[1];
-        if (this.map) {
-            this.map.panTo([lat, lng]);
-        }
-    };
-    LeafletMapAdapter.prototype.getCenter = function () {
-        var map = this.map;
-        if (map) {
-            var bounds = map.getBounds();
-            var center = bounds.getCenter();
-            return [center.lng, center.lat];
-        }
-    };
-    LeafletMapAdapter.prototype.setZoom = function (zoom) {
-        if (this.map) {
-            this.map.setZoom(zoom);
-        }
-    };
-    LeafletMapAdapter.prototype.getZoom = function () {
-        var _a;
-        return (_a = (this.map && this.map.getZoom())) !== null && _a !== void 0 ? _a : undefined;
-    };
-    LeafletMapAdapter.prototype.getBounds = function () {
-        if (!this.map)
-            return undefined;
-        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]
-    LeafletMapAdapter.prototype.fitBounds = function (bounds, options) {
-        if (options === void 0) { options = {}; }
-        if (this.map) {
-            var maxZoom = options.maxZoom, offset = options.offset, padding = options.padding;
-            var opt = {};
-            if (maxZoom) {
-                opt.maxZoom = maxZoom;
-            }
-            if (padding) {
-                opt.padding = [padding, padding];
-            }
-            if (offset) {
-                opt.padding = offset;
-            }
-            this.map.fitBounds(arrayToBoundsExpression(bounds), opt);
-        }
-    };
-    LeafletMapAdapter.prototype.getLayerAdapter = function (name) {
-        return LeafletMapAdapter.layerAdapters[name];
-    };
-    LeafletMapAdapter.prototype.createControl = function (control, options) {
-        return createControl(control, options, this);
-    };
-    LeafletMapAdapter.prototype.createButtonControl = function (options) {
-        return createButtonControl(options, this);
-    };
-    LeafletMapAdapter.prototype.addControl = function (control, position) {
-        control.options.position = position.replace('-', '');
-        if (this.map) {
-            this.map.addControl(control);
-            return control;
-        }
-    };
-    LeafletMapAdapter.prototype.removeControl = function (control) {
-        if (this.map) {
-            this.map.removeControl(control);
-        }
-    };
-    LeafletMapAdapter.prototype.removeLayer = function (layer) {
-        layer && layer.remove && layer.remove();
-    };
-    LeafletMapAdapter.prototype.showLayer = function (layer) {
-        if (this.map) {
-            layer.addTo(this.map);
-        }
-    };
-    LeafletMapAdapter.prototype.hideLayer = function (layer) {
-        layer.remove();
-    };
-    LeafletMapAdapter.prototype.setLayerOpacity = function (layer, value) {
-        if ('setOpacity' in layer) {
-            layer.setOpacity(value);
-        }
-    };
-    LeafletMapAdapter.prototype.setLayerOrder = function (layer, order, layers) {
-        //
-    };
-    LeafletMapAdapter.prototype.onMapClick = function (evt) {
-        var converted = convertMapClickEvent(evt);
-        this.emitter.emit('preclick', converted);
-        this.emitter.emit('click', converted);
-    };
-    LeafletMapAdapter.prototype.locate = function (opt, events) {
-        var map = this.map;
-        if (map) {
-            map.locate(opt);
-            if (events) {
-                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_1 !== undefined) {
-                    map.on('locationfound', locationFound_1, this);
-                }
-                if (locationerror_1) {
-                    map.on('locationerror', locationerror_1, this);
-                }
-                var stop_1 = function () {
-                    if (locationfound_1 !== undefined) {
-                        map.off('locationfound', locationFound_1);
-                    }
-                    if (locationerror_1) {
-                        map.off('locationerror', locationerror_1);
-                    }
-                };
-                return { stop: stop_1 };
-            }
-        }
-        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);
-    };
-    LeafletMapAdapter.prototype._watchSizeChangeToUpdateMinZoom = function (bounds) {
-        this._stopWatchSizeChangeToUpdateMinZoom();
-        var container = this.getContainer();
-        var map = this.map;
-        if (container && map && window.ResizeObserver) {
-            this._resizeObserver = new ResizeObserver(function () {
-                map.setMinZoom(map.getBoundsZoom(bounds));
-            });
-            this._resizeObserver.observe(container);
-        }
-    };
-    LeafletMapAdapter.prototype._stopWatchSizeChangeToUpdateMinZoom = function () {
-        var map = this.map;
-        if (map) {
-            map.setMinZoom(0);
-        }
-        if (this._resizeObserver) {
-            this._resizeObserver.disconnect();
-            this._resizeObserver = undefined;
-        }
-    };
-    LeafletMapAdapter.prototype._addMapListeners = function () {
-        var _this = this;
-        var map = this.map;
-        if (map) {
-            map.on('click', function (evt) {
-                _this.onMapClick(evt);
-            });
-            var _loop_1 = function (e) {
-                map.on(e, function () { return _this.emitter.emit(e, _this); }, map);
-            };
-            for (var _i = 0, _a = this._universalEvents; _i < _a.length; _i++) {
-                var e = _a[_i];
-                _loop_1(e);
-            }
-            var _loop_2 = function (e) {
-                map.on(e, function (evt) {
-                    return _this.emitter.emit(e, convertMapClickEvent(evt));
-                }, map);
-            };
-            for (var _b = 0, _c = this._positionEvents; _b < _c.length; _b++) {
-                var e = _c[_b];
-                _loop_2(e);
-            }
-        }
-    };
-    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;
-}());
+class LeafletMapAdapter$1 {
+    constructor() {
+        this.options = { target: 'map' };
+        this.layerAdapters = LeafletMapAdapter$1.layerAdapters;
+        this.controlAdapters = LeafletMapAdapter$1.controlAdapters;
+        this.emitter = new EventEmitter();
+        this._unselectCb = [];
+        this._universalEvents = [
+            'move',
+            'zoom',
+            'zoomend',
+            'zoomstart',
+            'moveend',
+            'movestart',
+        ];
+        this._positionEvents = [
+            'mousemove',
+            'mouseout',
+            'mouseover',
+        ];
+    }
+    create(options) {
+        this.options = { ...options };
+        if (this.options.target) {
+            const { zoom, center, maxZoom, minZoom, maxBounds: mb, mapAdapterOptions, } = this.options;
+            this.map =
+                this.options.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,
+                    });
+            // create default pane
+            const defPane = this.map.createPane('order-0');
+            this.map._addUnselectCb = (def) => {
+                this._addUnselectCb(def);
+            };
+            defPane.style.zIndex = String(0);
+            this.emitter.emit('create', this);
+            this._addMapListeners();
+        }
+    }
+    destroy() {
+        if (this.map) {
+            this.map.remove();
+        }
+        this._stopWatchSizeChangeToUpdateMinZoom();
+    }
+    getContainer() {
+        return this.map && this.map.getContainer();
+    }
+    getControlContainer() {
+        const controlContainer = this.map && this.map._controlContainer;
+        if (controlContainer) {
+            return controlContainer;
+        }
+        throw new Error('Leaflet Map is not initialized yet');
+    }
+    setCursor(cursor) {
+        if (this.map) {
+            this.map.getContainer().style.cursor = cursor;
+        }
+    }
+    setView(lngLatOrOpt, zoom) {
+        const map = this.map;
+        if (!map)
+            return;
+        if (Array.isArray(lngLatOrOpt)) {
+            const lngLat = lngLatOrOpt;
+            const [lng, lat] = lngLat;
+            if (this.map) {
+                if (typeof zoom === 'number') {
+                    this.map.setView([lat, lng], zoom, { animate: false });
+                }
+                else {
+                    this.setCenter([lng, lat]);
+                }
+            }
+        }
+        else {
+            const { zoom, center, maxBounds, bounds, minZoom, maxZoom } = lngLatOrOpt;
+            if (center && zoom !== undefined) {
+                this.setView(center, zoom);
+            }
+            else {
+                if (zoom !== undefined) {
+                    this.setZoom(zoom);
+                }
+                if (center) {
+                    this.setCenter(center);
+                }
+            }
+            if (bounds) {
+                this.fitBounds(bounds);
+            }
+            if (maxBounds !== undefined) {
+                if (maxBounds) {
+                    const b = arrayToBoundsExpression(maxBounds);
+                    map.setMaxBounds(b);
+                    map.setMinZoom(map.getBoundsZoom(b));
+                    this._watchSizeChangeToUpdateMinZoom(b);
+                }
+                else {
+                    // @ts-ignore `null` works for unset maxBounds, but not in typing
+                    map.setMaxBounds(null);
+                    this._stopWatchSizeChangeToUpdateMinZoom();
+                }
+            }
+            if (maxZoom !== undefined) {
+                map.setMaxZoom(maxZoom);
+            }
+            if (minZoom !== undefined) {
+                this._stopWatchSizeChangeToUpdateMinZoom();
+                map.setMinZoom(minZoom);
+            }
+        }
+    }
+    setCenter(lngLat) {
+        const [lng, lat] = lngLat;
+        if (this.map) {
+            this.map.panTo([lat, lng]);
+        }
+    }
+    getCenter() {
+        const map = this.map;
+        if (map) {
+            const bounds = map.getBounds();
+            const center = bounds.getCenter();
+            return [center.lng, center.lat];
+        }
+    }
+    setZoom(zoom) {
+        if (this.map) {
+            this.map.setZoom(zoom);
+        }
+    }
+    getZoom() {
+        var _a;
+        return (_a = (this.map && this.map.getZoom())) !== null && _a !== void 0 ? _a : undefined;
+    }
+    getBounds() {
+        if (!this.map)
+            return undefined;
+        const b = this.map.getBounds();
+        const sw = b.getSouthWest();
+        const ne = b.getNorthEast();
+        return [sw.lng, sw.lat, ne.lng, ne.lat];
+    }
+    // [west, south, east, north]
+    fitBounds(bounds, options = {}) {
+        if (this.map) {
+            const { maxZoom, offset, padding } = options;
+            const opt = {};
+            if (maxZoom) {
+                opt.maxZoom = maxZoom;
+            }
+            if (padding) {
+                opt.padding = [padding, padding];
+            }
+            if (offset) {
+                opt.padding = offset;
+            }
+            this.map.fitBounds(arrayToBoundsExpression(bounds), opt);
+        }
+    }
+    getLayerAdapter(name) {
+        return LeafletMapAdapter$1.layerAdapters[name];
+    }
+    createControl(control, options) {
+        return createControl(control, options, this);
+    }
+    createButtonControl(options) {
+        return createButtonControl(options, this);
+    }
+    addControl(control, position) {
+        control.options.position = position.replace('-', '');
+        if (this.map) {
+            this.map.addControl(control);
+            return control;
+        }
+    }
+    removeControl(control) {
+        if (this.map) {
+            this.map.removeControl(control);
+        }
+    }
+    removeLayer(layer) {
+        layer && layer.remove && layer.remove();
+    }
+    showLayer(layer) {
+        if (this.map) {
+            layer.addTo(this.map);
+        }
+    }
+    hideLayer(layer) {
+        layer.remove();
+    }
+    setLayerOpacity(layer, value) {
+        if ('setOpacity' in layer) {
+            layer.setOpacity(value);
+        }
+    }
+    setLayerOrder(layer, order, layers) {
+        //
+    }
+    onMapClick(evt) {
+        const converted = convertMapClickEvent(evt);
+        this.emitter.emit('preclick', converted);
+        this.emitter.emit('click', converted);
+    }
+    locate(opt, events) {
+        const 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 });
+                };
+                if (locationfound !== undefined) {
+                    map.on('locationfound', locationFound, this);
+                }
+                if (locationerror) {
+                    map.on('locationerror', locationerror, this);
+                }
+                const stop = () => {
+                    if (locationfound !== undefined) {
+                        map.off('locationfound', locationFound);
+                    }
+                    if (locationerror) {
+                        map.off('locationerror', locationerror);
+                    }
+                };
+                return { stop };
+            }
+        }
+        const stop = () => void 'fake function';
+        return { stop };
+    }
+    _addUnselectCb(cb) {
+        for (const p of this._unselectCb) {
+            p();
+        }
+        this._unselectCb.length = 0;
+        this._unselectCb.push(cb);
+    }
+    _watchSizeChangeToUpdateMinZoom(bounds) {
+        this._stopWatchSizeChangeToUpdateMinZoom();
+        const container = this.getContainer();
+        const map = this.map;
+        if (container && map && window.ResizeObserver) {
+            this._resizeObserver = new ResizeObserver(() => {
+                map.setMinZoom(map.getBoundsZoom(bounds));
+            });
+            this._resizeObserver.observe(container);
+        }
+    }
+    _stopWatchSizeChangeToUpdateMinZoom() {
+        const map = this.map;
+        if (map) {
+            map.setMinZoom(0);
+        }
+        if (this._resizeObserver) {
+            this._resizeObserver.disconnect();
+            this._resizeObserver = undefined;
+        }
+    }
+    _addMapListeners() {
+        const map = this.map;
+        if (map) {
+            map.on('click', (evt) => {
+                this.onMapClick(evt);
+            });
+            for (const e of this._universalEvents) {
+                map.on(e, () => this.emitter.emit(e, this), map);
+            }
+            for (const e of this._positionEvents) {
+                map.on(e, (evt) => this.emitter.emit(e, convertMapClickEvent(evt)), 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;
 
-/**
- * @module leaflet-map-adapter
- */
+/**
+ * @module leaflet-map-adapter
+ */
 var LeafletMapAdapter = LeafletMapAdapter$1;
 
 export { LeafletMapAdapter as default };