gis-leaflet-helper 1.0.1 → 1.0.2

package/dist/gis-leaflet-helper.es.js

@@ -2692,17 +2692,17 @@ var leafletSrc = { exports: {} };
           this._layers[i].layer.off("add remove", this._onLayerChange, this);
         }
       },
-      addBaseLayer: function(layer2, name) {
-        this._addLayer(layer2, name);
+      addBaseLayer: function(layer, name) {
+        this._addLayer(layer, name);
         return this._map ? this._update() : this;
       },
-      addOverlay: function(layer2, name) {
-        this._addLayer(layer2, name, true);
+      addOverlay: function(layer, name) {
+        this._addLayer(layer, name, true);
         return this._map ? this._update() : this;
       },
-      removeLayer: function(layer2) {
-        layer2.off("add remove", this._onLayerChange, this);
-        var obj = this._getLayer(stamp(layer2));
+      removeLayer: function(layer) {
+        layer.off("add remove", this._onLayerChange, this);
+        var obj = this._getLayer(stamp(layer));
         if (obj) {
           this._layers.splice(this._layers.indexOf(obj), 1);
         }
@@ -2765,12 +2765,12 @@ var leafletSrc = { exports: {} };
           }
         }
       },
-      _addLayer: function(layer2, name, overlay) {
+      _addLayer: function(layer, name, overlay) {
         if (this._map) {
-          layer2.on("add remove", this._onLayerChange, this);
+          layer.on("add remove", this._onLayerChange, this);
         }
         this._layers.push({
-          layer: layer2,
+          layer,
           name,
           overlay
         });
@@ -2779,9 +2779,9 @@ var leafletSrc = { exports: {} };
             return this.options.sortFunction(a.layer, b.layer, a.name, b.name);
           }, this));
         }
-        if (this.options.autoZIndex && layer2.setZIndex) {
+        if (this.options.autoZIndex && layer.setZIndex) {
           this._lastZIndex++;
-          layer2.setZIndex(this._lastZIndex);
+          layer.setZIndex(this._lastZIndex);
         }
         this._expandIfNotCollapsed();
       },
@@ -2848,16 +2848,16 @@ var leafletSrc = { exports: {} };
         return label;
       },
       _onInputClick: function() {
-        var inputs = this._layerControlInputs, input, layer2;
+        var inputs = this._layerControlInputs, input, layer;
         var addedLayers = [], removedLayers = [];
         this._handlingClick = true;
         for (var i = inputs.length - 1; i >= 0; i--) {
           input = inputs[i];
-          layer2 = this._getLayer(input.layerId).layer;
+          layer = this._getLayer(input.layerId).layer;
           if (input.checked) {
-            addedLayers.push(layer2);
+            addedLayers.push(layer);
           } else if (!input.checked) {
-            removedLayers.push(layer2);
+            removedLayers.push(layer);
           }
         }
         for (i = 0; i < removedLayers.length; i++) {
@@ -2874,11 +2874,11 @@ var leafletSrc = { exports: {} };
         this._refocusOnMap();
       },
       _checkDisabledLayers: function() {
-        var inputs = this._layerControlInputs, input, layer2, zoom2 = this._map.getZoom();
+        var inputs = this._layerControlInputs, input, layer, zoom2 = this._map.getZoom();
         for (var i = inputs.length - 1; i >= 0; i--) {
           input = inputs[i];
-          layer2 = this._getLayer(input.layerId).layer;
-          input.disabled = layer2.options.minZoom !== void 0 && zoom2 < layer2.options.minZoom || layer2.options.maxZoom !== void 0 && zoom2 > layer2.options.maxZoom;
+          layer = this._getLayer(input.layerId).layer;
+          input.disabled = layer.options.minZoom !== void 0 && zoom2 < layer.options.minZoom || layer.options.maxZoom !== void 0 && zoom2 > layer.options.maxZoom;
         }
       },
       _expandIfNotCollapsed: function() {
@@ -3597,40 +3597,40 @@ var leafletSrc = { exports: {} };
       }
     });
     Map.include({
-      addLayer: function(layer2) {
-        if (!layer2._layerAdd) {
+      addLayer: function(layer) {
+        if (!layer._layerAdd) {
           throw new Error("The provided object is not a Layer.");
         }
-        var id = stamp(layer2);
+        var id = stamp(layer);
         if (this._layers[id]) {
           return this;
         }
-        this._layers[id] = layer2;
-        layer2._mapToAdd = this;
-        if (layer2.beforeAdd) {
-          layer2.beforeAdd(this);
+        this._layers[id] = layer;
+        layer._mapToAdd = this;
+        if (layer.beforeAdd) {
+          layer.beforeAdd(this);
         }
-        this.whenReady(layer2._layerAdd, layer2);
+        this.whenReady(layer._layerAdd, layer);
         return this;
       },
-      removeLayer: function(layer2) {
-        var id = stamp(layer2);
+      removeLayer: function(layer) {
+        var id = stamp(layer);
         if (!this._layers[id]) {
           return this;
         }
         if (this._loaded) {
-          layer2.onRemove(this);
+          layer.onRemove(this);
         }
         delete this._layers[id];
         if (this._loaded) {
-          this.fire("layerremove", { layer: layer2 });
-          layer2.fire("remove");
+          this.fire("layerremove", { layer });
+          layer.fire("remove");
         }
-        layer2._map = layer2._mapToAdd = null;
+        layer._map = layer._mapToAdd = null;
         return this;
       },
-      hasLayer: function(layer2) {
-        return stamp(layer2) in this._layers;
+      hasLayer: function(layer) {
+        return stamp(layer) in this._layers;
       },
       eachLayer: function(method, context) {
         for (var i in this._layers) {
@@ -3644,14 +3644,14 @@ var leafletSrc = { exports: {} };
           this.addLayer(layers2[i]);
         }
       },
-      _addZoomLimit: function(layer2) {
-        if (!isNaN(layer2.options.maxZoom) || !isNaN(layer2.options.minZoom)) {
-          this._zoomBoundLayers[stamp(layer2)] = layer2;
+      _addZoomLimit: function(layer) {
+        if (!isNaN(layer.options.maxZoom) || !isNaN(layer.options.minZoom)) {
+          this._zoomBoundLayers[stamp(layer)] = layer;
           this._updateZoomLevels();
         }
       },
-      _removeZoomLimit: function(layer2) {
-        var id = stamp(layer2);
+      _removeZoomLimit: function(layer) {
+        var id = stamp(layer);
         if (this._zoomBoundLayers[id]) {
           delete this._zoomBoundLayers[id];
           this._updateZoomLevels();
@@ -3688,35 +3688,35 @@ var leafletSrc = { exports: {} };
           }
         }
       },
-      addLayer: function(layer2) {
-        var id = this.getLayerId(layer2);
-        this._layers[id] = layer2;
+      addLayer: function(layer) {
+        var id = this.getLayerId(layer);
+        this._layers[id] = layer;
         if (this._map) {
-          this._map.addLayer(layer2);
+          this._map.addLayer(layer);
         }
         return this;
       },
-      removeLayer: function(layer2) {
-        var id = layer2 in this._layers ? layer2 : this.getLayerId(layer2);
+      removeLayer: function(layer) {
+        var id = layer in this._layers ? layer : this.getLayerId(layer);
         if (this._map && this._layers[id]) {
           this._map.removeLayer(this._layers[id]);
         }
         delete this._layers[id];
         return this;
       },
-      hasLayer: function(layer2) {
-        var layerId = typeof layer2 === "number" ? layer2 : this.getLayerId(layer2);
+      hasLayer: function(layer) {
+        var layerId = typeof layer === "number" ? layer : this.getLayerId(layer);
         return layerId in this._layers;
       },
       clearLayers: function() {
         return this.eachLayer(this.removeLayer, this);
       },
       invoke: function(methodName) {
-        var args = Array.prototype.slice.call(arguments, 1), i, layer2;
+        var args = Array.prototype.slice.call(arguments, 1), i, layer;
         for (i in this._layers) {
-          layer2 = this._layers[i];
-          if (layer2[methodName]) {
-            layer2[methodName].apply(layer2, args);
+          layer = this._layers[i];
+          if (layer[methodName]) {
+            layer[methodName].apply(layer, args);
           }
         }
         return this;
@@ -3744,32 +3744,32 @@ var leafletSrc = { exports: {} };
       setZIndex: function(zIndex) {
         return this.invoke("setZIndex", zIndex);
       },
-      getLayerId: function(layer2) {
-        return stamp(layer2);
+      getLayerId: function(layer) {
+        return stamp(layer);
       }
     });
     var layerGroup = function(layers2, options) {
       return new LayerGroup(layers2, options);
     };
     var FeatureGroup = LayerGroup.extend({
-      addLayer: function(layer2) {
-        if (this.hasLayer(layer2)) {
+      addLayer: function(layer) {
+        if (this.hasLayer(layer)) {
           return this;
         }
-        layer2.addEventParent(this);
-        LayerGroup.prototype.addLayer.call(this, layer2);
-        return this.fire("layeradd", { layer: layer2 });
+        layer.addEventParent(this);
+        LayerGroup.prototype.addLayer.call(this, layer);
+        return this.fire("layeradd", { layer });
       },
-      removeLayer: function(layer2) {
-        if (!this.hasLayer(layer2)) {
+      removeLayer: function(layer) {
+        if (!this.hasLayer(layer)) {
           return this;
         }
-        if (layer2 in this._layers) {
-          layer2 = this._layers[layer2];
+        if (layer in this._layers) {
+          layer = this._layers[layer];
         }
-        layer2.removeEventParent(this);
-        LayerGroup.prototype.removeLayer.call(this, layer2);
-        return this.fire("layerremove", { layer: layer2 });
+        layer.removeEventParent(this);
+        LayerGroup.prototype.removeLayer.call(this, layer);
+        return this.fire("layerremove", { layer });
       },
       setStyle: function(style2) {
         return this.invoke("setStyle", style2);
@@ -3783,8 +3783,8 @@ var leafletSrc = { exports: {} };
       getBounds: function() {
         var bounds = new LatLngBounds();
         for (var id in this._layers) {
-          var layer2 = this._layers[id];
-          bounds.extend(layer2.getBounds ? layer2.getBounds() : layer2.getLatLng());
+          var layer = this._layers[id];
+          bounds.extend(layer.getBounds ? layer.getBounds() : layer.getLatLng());
         }
         return bounds;
       }
@@ -3962,7 +3962,7 @@ var leafletSrc = { exports: {} };
         this._marker.fire("moveend").fire("dragend", e);
       }
     });
-    var Marker2 = Layer.extend({
+    var Marker = Layer.extend({
       options: {
         icon: new IconDefault(),
         interactive: true,
@@ -4200,7 +4200,7 @@ var leafletSrc = { exports: {} };
       }
     });
     function marker(latlng, options) {
-      return new Marker2(latlng, options);
+      return new Marker(latlng, options);
     }
     var Path = Layer.extend({
       options: {
@@ -4680,37 +4680,37 @@ var leafletSrc = { exports: {} };
         if (options.filter && !options.filter(geojson)) {
           return this;
         }
-        var layer2 = geometryToLayer(geojson, options);
-        if (!layer2) {
+        var layer = geometryToLayer(geojson, options);
+        if (!layer) {
           return this;
         }
-        layer2.feature = asFeature(geojson);
-        layer2.defaultOptions = layer2.options;
-        this.resetStyle(layer2);
+        layer.feature = asFeature(geojson);
+        layer.defaultOptions = layer.options;
+        this.resetStyle(layer);
         if (options.onEachFeature) {
-          options.onEachFeature(geojson, layer2);
+          options.onEachFeature(geojson, layer);
         }
-        return this.addLayer(layer2);
+        return this.addLayer(layer);
       },
-      resetStyle: function(layer2) {
-        if (layer2 === void 0) {
+      resetStyle: function(layer) {
+        if (layer === void 0) {
           return this.eachLayer(this.resetStyle, this);
         }
-        layer2.options = extend({}, layer2.defaultOptions);
-        this._setLayerStyle(layer2, this.options.style);
+        layer.options = extend({}, layer.defaultOptions);
+        this._setLayerStyle(layer, this.options.style);
         return this;
       },
       setStyle: function(style2) {
-        return this.eachLayer(function(layer2) {
-          this._setLayerStyle(layer2, style2);
+        return this.eachLayer(function(layer) {
+          this._setLayerStyle(layer, style2);
         }, this);
       },
-      _setLayerStyle: function(layer2, style2) {
-        if (layer2.setStyle) {
+      _setLayerStyle: function(layer, style2) {
+        if (layer.setStyle) {
           if (typeof style2 === "function") {
-            style2 = style2(layer2.feature);
+            style2 = style2(layer.feature);
           }
-          layer2.setStyle(style2);
+          layer.setStyle(style2);
         }
       }
     });
@@ -4739,13 +4739,13 @@ var leafletSrc = { exports: {} };
           return new Polygon(latlngs, options);
         case "GeometryCollection":
           for (i = 0, len = geometry.geometries.length; i < len; i++) {
-            var layer2 = geometryToLayer({
+            var layer = geometryToLayer({
               geometry: geometry.geometries[i],
               type: "Feature",
               properties: geojson.properties
             }, options);
-            if (layer2) {
-              layers2.push(layer2);
+            if (layer) {
+              layers2.push(layer);
             }
           }
           return new FeatureGroup(layers2);
@@ -4754,7 +4754,7 @@ var leafletSrc = { exports: {} };
       }
     }
     function _pointToLayer(pointToLayerFn, geojson, latlng, options) {
-      return pointToLayerFn ? pointToLayerFn(geojson, latlng) : new Marker2(latlng, options && options.markersInheritOptions && options);
+      return pointToLayerFn ? pointToLayerFn(geojson, latlng) : new Marker(latlng, options && options.markersInheritOptions && options);
     }
     function coordsToLatLng(coords) {
       return new LatLng(coords[1], coords[0], coords[2]);
@@ -4781,8 +4781,8 @@ var leafletSrc = { exports: {} };
       }
       return coords;
     }
-    function getFeature(layer2, newGeometry) {
-      return layer2.feature ? extend({}, layer2.feature, { geometry: newGeometry }) : asFeature(newGeometry);
+    function getFeature(layer, newGeometry) {
+      return layer.feature ? extend({}, layer.feature, { geometry: newGeometry }) : asFeature(newGeometry);
     }
     function asFeature(geojson) {
       if (geojson.type === "Feature" || geojson.type === "FeatureCollection") {
@@ -4802,7 +4802,7 @@ var leafletSrc = { exports: {} };
         });
       }
     };
-    Marker2.include(PointToGeoJSON);
+    Marker.include(PointToGeoJSON);
     Circle.include(PointToGeoJSON);
     CircleMarker.include(PointToGeoJSON);
     Polyline.include({
@@ -4831,8 +4831,8 @@ var leafletSrc = { exports: {} };
     LayerGroup.include({
       toMultiPoint: function(precision) {
         var coords = [];
-        this.eachLayer(function(layer2) {
-          coords.push(layer2.toGeoJSON(precision).geometry.coordinates);
+        this.eachLayer(function(layer) {
+          coords.push(layer.toGeoJSON(precision).geometry.coordinates);
         });
         return getFeature(this, {
           type: "MultiPoint",
@@ -4845,9 +4845,9 @@ var leafletSrc = { exports: {} };
           return this.toMultiPoint(precision);
         }
         var isGeometryCollection = type === "GeometryCollection", jsons = [];
-        this.eachLayer(function(layer2) {
-          if (layer2.toGeoJSON) {
-            var json = layer2.toGeoJSON(precision);
+        this.eachLayer(function(layer) {
+          if (layer.toGeoJSON) {
+            var json = layer.toGeoJSON(precision);
             if (isGeometryCollection) {
               jsons.push(json.geometry);
             } else {
@@ -5122,17 +5122,17 @@ var leafletSrc = { exports: {} };
         }
         return this;
       },
-      toggle: function(layer2) {
+      toggle: function(layer) {
         if (this._map) {
           this.close();
         } else {
           if (arguments.length) {
-            this._source = layer2;
+            this._source = layer;
           } else {
-            layer2 = this._source;
+            layer = this._source;
           }
           this._prepareOpen();
-          this.openOn(layer2._map);
+          this.openOn(layer._map);
         }
         return this;
       },
@@ -6638,11 +6638,11 @@ var leafletSrc = { exports: {} };
         if (this._postponeUpdatePaths) {
           return;
         }
-        var layer2;
+        var layer;
         this._redrawBounds = null;
         for (var id in this._layers) {
-          layer2 = this._layers[id];
-          layer2._update();
+          layer = this._layers[id];
+          layer._update();
         }
         this._redraw();
       },
@@ -6670,11 +6670,11 @@ var leafletSrc = { exports: {} };
           this._updatePaths();
         }
       },
-      _initPath: function(layer2) {
-        this._updateDashArray(layer2);
-        this._layers[stamp(layer2)] = layer2;
-        var order = layer2._order = {
-          layer: layer2,
+      _initPath: function(layer) {
+        this._updateDashArray(layer);
+        this._layers[stamp(layer)] = layer;
+        var order = layer._order = {
+          layer,
           prev: this._drawLast,
           next: null
         };
@@ -6684,11 +6684,11 @@ var leafletSrc = { exports: {} };
         this._drawLast = order;
         this._drawFirst = this._drawFirst || this._drawLast;
       },
-      _addPath: function(layer2) {
-        this._requestRedraw(layer2);
+      _addPath: function(layer) {
+        this._requestRedraw(layer);
       },
-      _removePath: function(layer2) {
-        var order = layer2._order;
+      _removePath: function(layer) {
+        var order = layer._order;
         var next = order.next;
         var prev = order.prev;
         if (next) {
@@ -6701,23 +6701,23 @@ var leafletSrc = { exports: {} };
         } else {
           this._drawFirst = next;
         }
-        delete layer2._order;
-        delete this._layers[stamp(layer2)];
-        this._requestRedraw(layer2);
+        delete layer._order;
+        delete this._layers[stamp(layer)];
+        this._requestRedraw(layer);
       },
-      _updatePath: function(layer2) {
-        this._extendRedrawBounds(layer2);
-        layer2._project();
-        layer2._update();
-        this._requestRedraw(layer2);
+      _updatePath: function(layer) {
+        this._extendRedrawBounds(layer);
+        layer._project();
+        layer._update();
+        this._requestRedraw(layer);
       },
-      _updateStyle: function(layer2) {
-        this._updateDashArray(layer2);
-        this._requestRedraw(layer2);
+      _updateStyle: function(layer) {
+        this._updateDashArray(layer);
+        this._requestRedraw(layer);
       },
-      _updateDashArray: function(layer2) {
-        if (typeof layer2.options.dashArray === "string") {
-          var parts = layer2.options.dashArray.split(/[, ]+/), dashArray = [], dashValue, i;
+      _updateDashArray: function(layer) {
+        if (typeof layer.options.dashArray === "string") {
+          var parts = layer.options.dashArray.split(/[, ]+/), dashArray = [], dashValue, i;
           for (i = 0; i < parts.length; i++) {
             dashValue = Number(parts[i]);
             if (isNaN(dashValue)) {
@@ -6725,24 +6725,24 @@ var leafletSrc = { exports: {} };
             }
             dashArray.push(dashValue);
           }
-          layer2.options._dashArray = dashArray;
+          layer.options._dashArray = dashArray;
         } else {
-          layer2.options._dashArray = layer2.options.dashArray;
+          layer.options._dashArray = layer.options.dashArray;
         }
       },
-      _requestRedraw: function(layer2) {
+      _requestRedraw: function(layer) {
         if (!this._map) {
           return;
         }
-        this._extendRedrawBounds(layer2);
+        this._extendRedrawBounds(layer);
         this._redrawRequest = this._redrawRequest || requestAnimFrame(this._redraw, this);
       },
-      _extendRedrawBounds: function(layer2) {
-        if (layer2._pxBounds) {
-          var padding = (layer2.options.weight || 0) + 1;
+      _extendRedrawBounds: function(layer) {
+        if (layer._pxBounds) {
+          var padding = (layer.options.weight || 0) + 1;
           this._redrawBounds = this._redrawBounds || new Bounds();
-          this._redrawBounds.extend(layer2._pxBounds.min.subtract([padding, padding]));
-          this._redrawBounds.extend(layer2._pxBounds.max.add([padding, padding]));
+          this._redrawBounds.extend(layer._pxBounds.min.subtract([padding, padding]));
+          this._redrawBounds.extend(layer._pxBounds.max.add([padding, padding]));
         }
       },
       _redraw: function() {
@@ -6768,7 +6768,7 @@ var leafletSrc = { exports: {} };
         }
       },
       _draw: function() {
-        var layer2, bounds = this._redrawBounds;
+        var layer, bounds = this._redrawBounds;
         this._ctx.save();
         if (bounds) {
           var size = bounds.getSize();
@@ -6778,19 +6778,19 @@ var leafletSrc = { exports: {} };
         }
         this._drawing = true;
         for (var order = this._drawFirst; order; order = order.next) {
-          layer2 = order.layer;
-          if (!bounds || layer2._pxBounds && layer2._pxBounds.intersects(bounds)) {
-            layer2._updatePath();
+          layer = order.layer;
+          if (!bounds || layer._pxBounds && layer._pxBounds.intersects(bounds)) {
+            layer._updatePath();
           }
         }
         this._drawing = false;
         this._ctx.restore();
       },
-      _updatePoly: function(layer2, closed) {
+      _updatePoly: function(layer, closed) {
         if (!this._drawing) {
           return;
         }
-        var i, j, len2, p, parts = layer2._parts, len = parts.length, ctx = this._ctx;
+        var i, j, len2, p, parts = layer._parts, len = parts.length, ctx = this._ctx;
         if (!len) {
           return;
         }
@@ -6804,13 +6804,13 @@ var leafletSrc = { exports: {} };
             ctx.closePath();
           }
         }
-        this._fillStroke(ctx, layer2);
+        this._fillStroke(ctx, layer);
       },
-      _updateCircle: function(layer2) {
-        if (!this._drawing || layer2._empty()) {
+      _updateCircle: function(layer) {
+        if (!this._drawing || layer._empty()) {
           return;
         }
-        var p = layer2._point, ctx = this._ctx, r = Math.max(Math.round(layer2._radius), 1), s = (Math.max(Math.round(layer2._radiusY), 1) || r) / r;
+        var p = layer._point, ctx = this._ctx, r = Math.max(Math.round(layer._radius), 1), s = (Math.max(Math.round(layer._radiusY), 1) || r) / r;
         if (s !== 1) {
           ctx.save();
           ctx.scale(1, s);
@@ -6820,10 +6820,10 @@ var leafletSrc = { exports: {} };
         if (s !== 1) {
           ctx.restore();
         }
-        this._fillStroke(ctx, layer2);
+        this._fillStroke(ctx, layer);
       },
-      _fillStroke: function(ctx, layer2) {
-        var options = layer2.options;
+      _fillStroke: function(ctx, layer) {
+        var options = layer.options;
         if (options.fill) {
           ctx.globalAlpha = options.fillOpacity;
           ctx.fillStyle = options.fillColor || options.color;
@@ -6831,7 +6831,7 @@ var leafletSrc = { exports: {} };
         }
         if (options.stroke && options.weight !== 0) {
           if (ctx.setLineDash) {
-            ctx.setLineDash(layer2.options && layer2.options._dashArray || []);
+            ctx.setLineDash(layer.options && layer.options._dashArray || []);
           }
           ctx.globalAlpha = options.opacity;
           ctx.lineWidth = options.weight;
@@ -6842,12 +6842,12 @@ var leafletSrc = { exports: {} };
         }
       },
       _onClick: function(e) {
-        var point = this._map.mouseEventToLayerPoint(e), layer2, clickedLayer;
+        var point = this._map.mouseEventToLayerPoint(e), layer, clickedLayer;
         for (var order = this._drawFirst; order; order = order.next) {
-          layer2 = order.layer;
-          if (layer2.options.interactive && layer2._containsPoint(point)) {
-            if (!(e.type === "click" || e.type === "preclick") || !this._map._draggableMoved(layer2)) {
-              clickedLayer = layer2;
+          layer = order.layer;
+          if (layer.options.interactive && layer._containsPoint(point)) {
+            if (!(e.type === "click" || e.type === "preclick") || !this._map._draggableMoved(layer)) {
+              clickedLayer = layer;
             }
           }
         }
@@ -6861,10 +6861,10 @@ var leafletSrc = { exports: {} };
         this._handleMouseHover(e, point);
       },
       _handleMouseOut: function(e) {
-        var layer2 = this._hoveredLayer;
-        if (layer2) {
+        var layer = this._hoveredLayer;
+        if (layer) {
           removeClass(this._container, "leaflet-interactive");
-          this._fireEvent([layer2], e, "mouseout");
+          this._fireEvent([layer], e, "mouseout");
           this._hoveredLayer = null;
           this._mouseHoverThrottled = false;
         }
@@ -6873,11 +6873,11 @@ var leafletSrc = { exports: {} };
         if (this._mouseHoverThrottled) {
           return;
         }
-        var layer2, candidateHoveredLayer;
+        var layer, candidateHoveredLayer;
         for (var order = this._drawFirst; order; order = order.next) {
-          layer2 = order.layer;
-          if (layer2.options.interactive && layer2._containsPoint(point)) {
-            candidateHoveredLayer = layer2;
+          layer = order.layer;
+          if (layer.options.interactive && layer._containsPoint(point)) {
+            candidateHoveredLayer = layer;
           }
         }
         if (candidateHoveredLayer !== this._hoveredLayer) {
@@ -6897,8 +6897,8 @@ var leafletSrc = { exports: {} };
       _fireEvent: function(layers2, e, type) {
         this._map._fireDOMEvent(e, type || e.type, layers2);
       },
-      _bringToFront: function(layer2) {
-        var order = layer2._order;
+      _bringToFront: function(layer) {
+        var order = layer._order;
         if (!order) {
           return;
         }
@@ -6918,10 +6918,10 @@ var leafletSrc = { exports: {} };
         this._drawLast.next = order;
         order.next = null;
         this._drawLast = order;
-        this._requestRedraw(layer2);
+        this._requestRedraw(layer);
       },
-      _bringToBack: function(layer2) {
-        var order = layer2._order;
+      _bringToBack: function(layer) {
+        var order = layer._order;
         if (!order) {
           return;
         }
@@ -6941,7 +6941,7 @@ var leafletSrc = { exports: {} };
         order.next = this._drawFirst;
         this._drawFirst.prev = order;
         this._drawFirst = order;
-        this._requestRedraw(layer2);
+        this._requestRedraw(layer);
       }
     });
     function canvas(options) {
@@ -6970,35 +6970,35 @@ var leafletSrc = { exports: {} };
         Renderer.prototype._update.call(this);
         this.fire("update");
       },
-      _initPath: function(layer2) {
-        var container = layer2._container = vmlCreate("shape");
+      _initPath: function(layer) {
+        var container = layer._container = vmlCreate("shape");
         addClass(container, "leaflet-vml-shape " + (this.options.className || ""));
         container.coordsize = "1 1";
-        layer2._path = vmlCreate("path");
-        container.appendChild(layer2._path);
-        this._updateStyle(layer2);
-        this._layers[stamp(layer2)] = layer2;
+        layer._path = vmlCreate("path");
+        container.appendChild(layer._path);
+        this._updateStyle(layer);
+        this._layers[stamp(layer)] = layer;
       },
-      _addPath: function(layer2) {
-        var container = layer2._container;
+      _addPath: function(layer) {
+        var container = layer._container;
         this._container.appendChild(container);
-        if (layer2.options.interactive) {
-          layer2.addInteractiveTarget(container);
+        if (layer.options.interactive) {
+          layer.addInteractiveTarget(container);
         }
       },
-      _removePath: function(layer2) {
-        var container = layer2._container;
+      _removePath: function(layer) {
+        var container = layer._container;
         remove(container);
-        layer2.removeInteractiveTarget(container);
-        delete this._layers[stamp(layer2)];
+        layer.removeInteractiveTarget(container);
+        delete this._layers[stamp(layer)];
       },
-      _updateStyle: function(layer2) {
-        var stroke = layer2._stroke, fill = layer2._fill, options = layer2.options, container = layer2._container;
+      _updateStyle: function(layer) {
+        var stroke = layer._stroke, fill = layer._fill, options = layer.options, container = layer._container;
         container.stroked = !!options.stroke;
         container.filled = !!options.fill;
         if (options.stroke) {
           if (!stroke) {
-            stroke = layer2._stroke = vmlCreate("stroke");
+            stroke = layer._stroke = vmlCreate("stroke");
           }
           container.appendChild(stroke);
           stroke.weight = options.weight + "px";
@@ -7013,32 +7013,32 @@ var leafletSrc = { exports: {} };
           stroke.joinstyle = options.lineJoin;
         } else if (stroke) {
           container.removeChild(stroke);
-          layer2._stroke = null;
+          layer._stroke = null;
         }
         if (options.fill) {
           if (!fill) {
-            fill = layer2._fill = vmlCreate("fill");
+            fill = layer._fill = vmlCreate("fill");
           }
           container.appendChild(fill);
           fill.color = options.fillColor || options.color;
           fill.opacity = options.fillOpacity;
         } else if (fill) {
           container.removeChild(fill);
-          layer2._fill = null;
+          layer._fill = null;
         }
       },
-      _updateCircle: function(layer2) {
-        var p = layer2._point.round(), r = Math.round(layer2._radius), r2 = Math.round(layer2._radiusY || r);
-        this._setPath(layer2, layer2._empty() ? "M0 0" : "AL " + p.x + "," + p.y + " " + r + "," + r2 + " 0," + 65535 * 360);
+      _updateCircle: function(layer) {
+        var p = layer._point.round(), r = Math.round(layer._radius), r2 = Math.round(layer._radiusY || r);
+        this._setPath(layer, layer._empty() ? "M0 0" : "AL " + p.x + "," + p.y + " " + r + "," + r2 + " 0," + 65535 * 360);
       },
-      _setPath: function(layer2, path) {
-        layer2._path.v = path;
+      _setPath: function(layer, path) {
+        layer._path.v = path;
       },
-      _bringToFront: function(layer2) {
-        toFront(layer2._container);
+      _bringToFront: function(layer) {
+        toFront(layer._container);
       },
-      _bringToBack: function(layer2) {
-        toBack(layer2._container);
+      _bringToBack: function(layer) {
+        toBack(layer._container);
       }
     };
     var create = Browser.vml ? vmlCreate : svgCreate;
@@ -7071,35 +7071,35 @@ var leafletSrc = { exports: {} };
         container.setAttribute("viewBox", [b.min.x, b.min.y, size.x, size.y].join(" "));
         this.fire("update");
       },
-      _initPath: function(layer2) {
-        var path = layer2._path = create("path");
-        if (layer2.options.className) {
-          addClass(path, layer2.options.className);
+      _initPath: function(layer) {
+        var path = layer._path = create("path");
+        if (layer.options.className) {
+          addClass(path, layer.options.className);
         }
-        if (layer2.options.interactive) {
+        if (layer.options.interactive) {
           addClass(path, "leaflet-interactive");
         }
-        this._updateStyle(layer2);
-        this._layers[stamp(layer2)] = layer2;
+        this._updateStyle(layer);
+        this._layers[stamp(layer)] = layer;
       },
-      _addPath: function(layer2) {
+      _addPath: function(layer) {
         if (!this._rootGroup) {
           this._initContainer();
         }
-        this._rootGroup.appendChild(layer2._path);
-        layer2.addInteractiveTarget(layer2._path);
+        this._rootGroup.appendChild(layer._path);
+        layer.addInteractiveTarget(layer._path);
       },
-      _removePath: function(layer2) {
-        remove(layer2._path);
-        layer2.removeInteractiveTarget(layer2._path);
-        delete this._layers[stamp(layer2)];
+      _removePath: function(layer) {
+        remove(layer._path);
+        layer.removeInteractiveTarget(layer._path);
+        delete this._layers[stamp(layer)];
       },
-      _updatePath: function(layer2) {
-        layer2._project();
-        layer2._update();
+      _updatePath: function(layer) {
+        layer._project();
+        layer._update();
       },
-      _updateStyle: function(layer2) {
-        var path = layer2._path, options = layer2.options;
+      _updateStyle: function(layer) {
+        var path = layer._path, options = layer.options;
         if (!path) {
           return;
         }
@@ -7130,22 +7130,22 @@ var leafletSrc = { exports: {} };
           path.setAttribute("fill", "none");
         }
       },
-      _updatePoly: function(layer2, closed) {
-        this._setPath(layer2, pointsToPath(layer2._parts, closed));
+      _updatePoly: function(layer, closed) {
+        this._setPath(layer, pointsToPath(layer._parts, closed));
       },
-      _updateCircle: function(layer2) {
-        var p = layer2._point, r = Math.max(Math.round(layer2._radius), 1), r2 = Math.max(Math.round(layer2._radiusY), 1) || r, arc = "a" + r + "," + r2 + " 0 1,0 ";
-        var d = layer2._empty() ? "M0 0" : "M" + (p.x - r) + "," + p.y + arc + r * 2 + ",0 " + arc + -r * 2 + ",0 ";
-        this._setPath(layer2, d);
+      _updateCircle: function(layer) {
+        var p = layer._point, r = Math.max(Math.round(layer._radius), 1), r2 = Math.max(Math.round(layer._radiusY), 1) || r, arc = "a" + r + "," + r2 + " 0 1,0 ";
+        var d = layer._empty() ? "M0 0" : "M" + (p.x - r) + "," + p.y + arc + r * 2 + ",0 " + arc + -r * 2 + ",0 ";
+        this._setPath(layer, d);
       },
-      _setPath: function(layer2, path) {
-        layer2._path.setAttribute("d", path);
+      _setPath: function(layer, path) {
+        layer._path.setAttribute("d", path);
       },
-      _bringToFront: function(layer2) {
-        toFront(layer2._path);
+      _bringToFront: function(layer) {
+        toFront(layer._path);
       },
-      _bringToBack: function(layer2) {
-        toBack(layer2._path);
+      _bringToBack: function(layer) {
+        toBack(layer._path);
       }
     });
     if (Browser.vml) {
@@ -7155,8 +7155,8 @@ var leafletSrc = { exports: {} };
       return Browser.svg || Browser.vml ? new SVG(options) : null;
     }
     Map.include({
-      getRenderer: function(layer2) {
-        var renderer = layer2.options.renderer || this._getPaneRenderer(layer2.options.pane) || this.options.renderer || this._renderer;
+      getRenderer: function(layer) {
+        var renderer = layer.options.renderer || this._getPaneRenderer(layer.options.pane) || this.options.renderer || this._renderer;
         if (!renderer) {
           renderer = this._renderer = this._createRenderer();
         }
@@ -7795,7 +7795,7 @@ var leafletSrc = { exports: {} };
     exports2.LayerGroup = LayerGroup;
     exports2.LineUtil = LineUtil;
     exports2.Map = Map;
-    exports2.Marker = Marker2;
+    exports2.Marker = Marker;
     exports2.Mixin = Mixin;
     exports2.Path = Path;
     exports2.Point = Point;
@@ -7943,80 +7943,6 @@ var MyComponents = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   __proto__: null,
   BaseGlobe: Main
 }, Symbol.toStringTag, { value: "Module" }));
-var LayerManager = L.LayerGroup.extend({
-  initialize(options) {
-    L.Util.setOptions(this, options);
-    L.LayerGroup.prototype.initialize.call(this, options);
-  },
-  getRasterLayers() {
-    const _rasterLayers = {};
-    const _get = (_layer) => {
-      if (_layer._layers && _layer.getLayer) {
-        for (const key in _layer._layers) {
-          const layer2 = _layer._layers[key];
-          if (layer2._layers && layer2.getLayer) {
-            _get(layer2);
-          } else {
-            _rasterLayers[layer2._leaflet_id] = layer2;
-          }
-        }
-      } else {
-        _rasterLayers[layer._leaflet_id] = layer;
-      }
-    };
-    _get(this);
-    return _rasterLayers;
-  },
-  removeRasterLayer(id) {
-    const _remove = function(_layer) {
-      if (_layer._layers && _layer.getLayer && _layer.getLayer(id)) {
-        const data = _layer.getLayer(id);
-        _layer.removeLayer(data);
-      } else if (_layer._layers) {
-        for (const key in _layer._layers) {
-          const layer2 = _layer._layers[key];
-          if (layer2._layers && layer2.getLayer && layer2.getLayer(id)) {
-            const data = layer2.getLayer(id);
-            layer2.removeLayer(data);
-          } else if (layer2._layers) {
-            _remove(layer2);
-          }
-        }
-      }
-    };
-    _remove(this);
-  },
-  getRasterTop() {
-    const rasterLayers = Object.values(this.getRasterLayers());
-    return rasterLayers.length ? Math.max(...rasterLayers.map((d) => d.options.zIndex)) + 1 : null;
-  }
-});
-var Marker = L.Marker.extend({
-  initialize(latlng, options) {
-    L.Util.setOptions(this, options);
-    L.Marker.prototype.initialize.call(this, latlng, this.options);
-  },
-  twinkle(frequency, duration) {
-    let status = false;
-    let timer = 0;
-    const _ = () => {
-      timer++;
-      if (timer > Math.floor(duration / frequency)) {
-        this.setOpacity(1);
-      } else {
-        if (status) {
-          this.setOpacity(0);
-          status = false;
-        } else {
-          this.setOpacity(1);
-          status = true;
-        }
-        setTimeout(_, frequency);
-      }
-    };
-    _();
-  }
-});
 const install = function(Vue, options = {}) {
   if (install.installed)
     return;
@@ -8031,4 +7957,4 @@ if (typeof window !== "undefined" && window.Vue) {
 var index = __spreadValues({
   install
 }, MyComponents);
-export { BaseMap, LayerManager, Marker, index as default };
+export { BaseMap, index as default };