@mattilsynet/design 2.2.28 → 2.2.30

package/mtds/atlas/cluster.js

@@ -1,30 +1,30 @@
-import L from "../external/leaflet/dist/leaflet-src.js";
-L.MarkerClusterGroup = L.FeatureGroup.extend({
+import u from "../external/leaflet/dist/leaflet-src.js";
+u.MarkerClusterGroup = u.FeatureGroup.extend({
   options: {
     maxClusterRadius: 80,
     //A cluster will cover at most this many pixels from its center
     iconCreateFunction: null,
-    spiderfyOnMaxZoom: true,
-    showCoverageOnHover: true,
-    zoomToBoundsOnClick: true,
-    singleMarkerMode: false,
+    spiderfyOnMaxZoom: !0,
+    showCoverageOnHover: !0,
+    zoomToBoundsOnClick: !0,
+    singleMarkerMode: !1,
     disableClusteringAtZoom: null,
     // Setting this to false prevents the removal of any clusters outside of the viewpoint, which
     // is the default behaviour for performance reasons.
-    removeOutsideVisibleBounds: true,
+    removeOutsideVisibleBounds: !0,
     // Set to false to disable all animations (zoom and spiderfy).
     // If false, option animateAddingMarkers below has no effect.
     // If L.DomUtil.TRANSITION is falsy, this option has no effect.
-    animate: true,
+    animate: !0,
     //Whether to animate adding markers after adding the MarkerClusterGroup to the map
     // If you are adding individual markers set to true, if adding bulk markers leave false for massive performance gains.
-    animateAddingMarkers: false,
+    animateAddingMarkers: !1,
     //Increase to increase the distance away that spiderfied markers appear from the center
     spiderfyDistanceMultiplier: 1,
     // Make it possible to specify a polyline options on a spider leg
     spiderLegPolylineOptions: { weight: 1.5, color: "#222", opacity: 0.5 },
     // When bulk adding layers, adds markers in chunks. Means addLayers may not add all the layers in the call, others will be loaded during setTimeouts
-    chunkedLoading: false,
+    chunkedLoading: !1,
     chunkInterval: 200,
     // process markers for a maximum of ~ n milliseconds (then trigger the chunkProgress callback)
     chunkDelay: 50,
@@ -34,457 +34,211 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
     //Options to pass to the L.Polygon constructor
     polygonOptions: {}
   },
-  initialize: function(options) {
-    L.Util.setOptions(this, options);
-    if (!this.options.iconCreateFunction) {
-      this.options.iconCreateFunction = this._defaultIconCreateFunction;
-    }
-    if (!this.options.clusterPane) {
-      this.options.clusterPane = L.Marker.prototype.options.pane;
-    }
-    this._featureGroup = new L.FeatureGroup();
-    this._featureGroup.addEventParent(this);
-    this._nonPointGroup = new L.FeatureGroup();
-    this._nonPointGroup.addEventParent(this);
-    this._inZoomAnimation = 0;
-    this._needsClustering = [];
-    this._needsRemoving = [];
-    this._currentShownBounds = null;
-    this._queue = [];
-    this._childMarkerEventHandlers = {
+  initialize: function(t) {
+    u.Util.setOptions(this, t), this.options.iconCreateFunction || (this.options.iconCreateFunction = this._defaultIconCreateFunction), this.options.clusterPane || (this.options.clusterPane = u.Marker.prototype.options.pane), this._featureGroup = new u.FeatureGroup(), this._featureGroup.addEventParent(this), this._nonPointGroup = new u.FeatureGroup(), this._nonPointGroup.addEventParent(this), this._inZoomAnimation = 0, this._needsClustering = [], this._needsRemoving = [], this._currentShownBounds = null, this._queue = [], this._childMarkerEventHandlers = {
       dragstart: this._childMarkerDragStart,
       move: this._childMarkerMoved,
       dragend: this._childMarkerDragEnd
     };
-    var animate = L.DomUtil.TRANSITION && this.options.animate;
-    Object.assign(this, animate ? this._withAnimation : this._noAnimation);
-    this._markerCluster = animate ? L.MarkerCluster : L.MarkerClusterNonAnimated;
-  },
-  addLayer: function(layer) {
-    if (layer instanceof L.LayerGroup) {
-      return this.addLayers([layer]);
-    }
-    if (!layer.getLatLng) {
-      this._nonPointGroup.addLayer(layer);
-      this.fire("layeradd", { layer, propagatedFrom: layer });
+    var e = u.DomUtil.TRANSITION && this.options.animate;
+    Object.assign(this, e ? this._withAnimation : this._noAnimation), this._markerCluster = e ? u.MarkerCluster : u.MarkerClusterNonAnimated;
+  },
+  addLayer: function(t) {
+    if (t instanceof u.LayerGroup)
+      return this.addLayers([t]);
+    if (!t.getLatLng)
+      return this._nonPointGroup.addLayer(t), this.fire("layeradd", { layer: t, propagatedFrom: t }), this;
+    if (!this._map)
+      return this._needsClustering.push(t), this.fire("layeradd", { layer: t, propagatedFrom: t }), this;
+    if (this.hasLayer(t))
       return this;
-    }
-    if (!this._map) {
-      this._needsClustering.push(layer);
-      this.fire("layeradd", { layer, propagatedFrom: layer });
-      return this;
-    }
-    if (this.hasLayer(layer)) {
-      return this;
-    }
-    if (this._unspiderfy) {
-      this._unspiderfy();
-    }
-    this._addLayer(layer, this._maxZoom);
-    this.fire("layeradd", { layer, propagatedFrom: layer });
-    this._topClusterLevel._recalculateBounds();
-    this._refreshClustersIcons();
-    var visibleLayer = layer, currentZoom = this._zoom;
-    if (layer.__parent) {
-      while (visibleLayer.__parent._zoom >= currentZoom) {
-        visibleLayer = visibleLayer.__parent;
-      }
-    }
-    if (this._currentShownBounds.contains(visibleLayer.getLatLng())) {
-      if (this.options.animateAddingMarkers) {
-        this._animationAddLayer(layer, visibleLayer);
-      } else {
-        this._animationAddLayerNonAnimated(layer, visibleLayer);
-      }
-    }
-    return this;
+    this._unspiderfy && this._unspiderfy(), this._addLayer(t, this._maxZoom), this.fire("layeradd", { layer: t, propagatedFrom: t }), this._topClusterLevel._recalculateBounds(), this._refreshClustersIcons();
+    var e = t, i = this._zoom;
+    if (t.__parent)
+      for (; e.__parent._zoom >= i; )
+        e = e.__parent;
+    return this._currentShownBounds.contains(e.getLatLng()) && (this.options.animateAddingMarkers ? this._animationAddLayer(t, e) : this._animationAddLayerNonAnimated(t, e)), this;
   },
-  removeLayer: function(layer) {
-    if (layer instanceof L.LayerGroup) {
-      return this.removeLayers([layer]);
-    }
-    if (!layer.getLatLng) {
-      this._nonPointGroup.removeLayer(layer);
-      this.fire("layerremove", { layer, propagatedFrom: layer });
-      return this;
-    }
-    if (!this._map) {
-      if (!this._arraySplice(this._needsClustering, layer) && this.hasLayer(layer)) {
-        this._needsRemoving.push({ layer, latlng: layer._latlng });
-      }
-      this.fire("layerremove", { layer, propagatedFrom: layer });
-      return this;
-    }
-    if (!layer.__parent) {
-      return this;
-    }
-    if (this._unspiderfy) {
-      this._unspiderfy();
-      this._unspiderfyLayer(layer);
-    }
-    this._removeLayer(layer, true);
-    this.fire("layerremove", { layer, propagatedFrom: layer });
-    this._topClusterLevel._recalculateBounds();
-    this._refreshClustersIcons();
-    layer.off(this._childMarkerEventHandlers, this);
-    if (this._featureGroup.hasLayer(layer)) {
-      this._featureGroup.removeLayer(layer);
-      if (layer.clusterShow) {
-        layer.clusterShow();
-      }
-    }
-    return this;
+  removeLayer: function(t) {
+    return t instanceof u.LayerGroup ? this.removeLayers([t]) : t.getLatLng ? this._map ? t.__parent ? (this._unspiderfy && (this._unspiderfy(), this._unspiderfyLayer(t)), this._removeLayer(t, !0), this.fire("layerremove", { layer: t, propagatedFrom: t }), this._topClusterLevel._recalculateBounds(), this._refreshClustersIcons(), t.off(this._childMarkerEventHandlers, this), this._featureGroup.hasLayer(t) && (this._featureGroup.removeLayer(t), t.clusterShow && t.clusterShow()), this) : this : (!this._arraySplice(this._needsClustering, t) && this.hasLayer(t) && this._needsRemoving.push({ layer: t, latlng: t._latlng }), this.fire("layerremove", { layer: t, propagatedFrom: t }), this) : (this._nonPointGroup.removeLayer(t), this.fire("layerremove", { layer: t, propagatedFrom: t }), this);
   },
   //Takes an array of markers and adds them in bulk
-  addLayers: function(layersArray, skipLayerAddEvent) {
-    if (!Array.isArray(layersArray)) return this.addLayer(layersArray);
-    var fg = this._featureGroup, npg = this._nonPointGroup, chunked = this.options.chunkedLoading, chunkInterval = this.options.chunkInterval, chunkProgress = this.options.chunkProgress, l = layersArray.length, offset = 0, originalArray = true, m;
+  addLayers: function(t, e) {
+    if (!Array.isArray(t)) return this.addLayer(t);
+    var i = this._featureGroup, n = this._nonPointGroup, s = this.options.chunkedLoading, o = this.options.chunkInterval, r = this.options.chunkProgress, a = t.length, h = 0, _ = !0, l;
     if (this._map) {
-      const started = Date.now();
-      const process = () => {
-        var start = Date.now();
-        for (; offset < l; offset++) {
-          if (chunked && offset % 200 === 0) {
-            const elapsed = Date.now() - start;
-            if (elapsed > chunkInterval) {
-              break;
-            }
-          }
-          m = layersArray[offset];
-          if (m instanceof L.LayerGroup) {
-            if (originalArray) {
-              layersArray = layersArray.slice();
-              originalArray = false;
-            }
-            this._extractNonGroupLayers(m, layersArray);
-            l = layersArray.length;
+      const d = Date.now(), p = () => {
+        for (var f = Date.now(); h < a && !(s && h % 200 === 0 && Date.now() - f > o); h++) {
+          if (l = t[h], l instanceof u.LayerGroup) {
+            _ && (t = t.slice(), _ = !1), this._extractNonGroupLayers(l, t), a = t.length;
             continue;
           }
-          if (!m.getLatLng) {
-            npg.addLayer(m);
-            if (!skipLayerAddEvent) {
-              this.fire("layeradd", { layer: m, propagatedFrom: m });
-            }
+          if (!l.getLatLng) {
+            n.addLayer(l), e || this.fire("layeradd", { layer: l, propagatedFrom: l });
             continue;
           }
-          if (this.hasLayer(m)) {
-            continue;
-          }
-          this._addLayer(m, this._maxZoom);
-          if (!skipLayerAddEvent) {
-            this.fire("layeradd", { layer: m, propagatedFrom: m });
-          }
-          if (m.__parent) {
-            if (m.__parent.getChildCount() === 2) {
-              const markers = m.__parent.getAllChildMarkers();
-              const otherMarker = markers[0] === m ? markers[1] : markers[0];
-              fg.removeLayer(otherMarker);
-            }
+          if (!this.hasLayer(l) && (this._addLayer(l, this._maxZoom), e || this.fire("layeradd", { layer: l, propagatedFrom: l }), l.__parent && l.__parent.getChildCount() === 2)) {
+            const c = l.__parent.getAllChildMarkers(), g = c[0] === l ? c[1] : c[0];
+            i.removeLayer(g);
           }
         }
-        if (chunkProgress) {
-          chunkProgress(offset, l, Date.now() - started);
-        }
-        if (offset === l) {
-          this._topClusterLevel._recalculateBounds();
-          this._refreshClustersIcons();
-          this._topClusterLevel._recursivelyAddChildrenToMap(
-            null,
-            this._zoom,
-            this._currentShownBounds
-          );
-        } else {
-          setTimeout(process, this.options.chunkDelay);
-        }
+        r && r(h, a, Date.now() - d), h === a ? (this._topClusterLevel._recalculateBounds(), this._refreshClustersIcons(), this._topClusterLevel._recursivelyAddChildrenToMap(
+          null,
+          this._zoom,
+          this._currentShownBounds
+        )) : setTimeout(p, this.options.chunkDelay);
       };
-      process();
+      p();
     } else {
-      const needsClustering = this._needsClustering;
-      for (; offset < l; offset++) {
-        m = layersArray[offset];
-        if (m instanceof L.LayerGroup) {
-          if (originalArray) {
-            layersArray = layersArray.slice();
-            originalArray = false;
-          }
-          this._extractNonGroupLayers(m, layersArray);
-          l = layersArray.length;
-          continue;
-        }
-        if (!m.getLatLng) {
-          npg.addLayer(m);
+      const d = this._needsClustering;
+      for (; h < a; h++) {
+        if (l = t[h], l instanceof u.LayerGroup) {
+          _ && (t = t.slice(), _ = !1), this._extractNonGroupLayers(l, t), a = t.length;
           continue;
         }
-        if (this.hasLayer(m)) {
+        if (!l.getLatLng) {
+          n.addLayer(l);
           continue;
         }
-        needsClustering.push(m);
+        this.hasLayer(l) || d.push(l);
       }
     }
     return this;
   },
   //Takes an array of markers and removes them in bulk
-  removeLayers: function(layersArray) {
-    var i, m, l = layersArray.length, fg = this._featureGroup, npg = this._nonPointGroup, originalArray = true;
+  removeLayers: function(t) {
+    var e, i, n = t.length, s = this._featureGroup, o = this._nonPointGroup, r = !0;
     if (!this._map) {
-      for (i = 0; i < l; i++) {
-        m = layersArray[i];
-        if (m instanceof L.LayerGroup) {
-          if (originalArray) {
-            layersArray = layersArray.slice();
-            originalArray = false;
-          }
-          this._extractNonGroupLayers(m, layersArray);
-          l = layersArray.length;
+      for (e = 0; e < n; e++) {
+        if (i = t[e], i instanceof u.LayerGroup) {
+          r && (t = t.slice(), r = !1), this._extractNonGroupLayers(i, t), n = t.length;
           continue;
         }
-        this._arraySplice(this._needsClustering, m);
-        npg.removeLayer(m);
-        if (this.hasLayer(m)) {
-          this._needsRemoving.push({ layer: m, latlng: m._latlng });
-        }
-        this.fire("layerremove", { layer: m, propagatedFrom: m });
+        this._arraySplice(this._needsClustering, i), o.removeLayer(i), this.hasLayer(i) && this._needsRemoving.push({ layer: i, latlng: i._latlng }), this.fire("layerremove", { layer: i, propagatedFrom: i });
       }
       return this;
     }
     if (this._unspiderfy) {
       this._unspiderfy();
-      const layersArray2 = layersArray.slice();
-      let l2 = l;
-      for (i = 0; i < l2; i++) {
-        m = layersArray2[i];
-        if (m instanceof L.LayerGroup) {
-          this._extractNonGroupLayers(m, layersArray2);
-          l2 = layersArray2.length;
+      const a = t.slice();
+      let h = n;
+      for (e = 0; e < h; e++) {
+        if (i = a[e], i instanceof u.LayerGroup) {
+          this._extractNonGroupLayers(i, a), h = a.length;
           continue;
         }
-        this._unspiderfyLayer(m);
+        this._unspiderfyLayer(i);
       }
     }
-    for (i = 0; i < l; i++) {
-      m = layersArray[i];
-      if (m instanceof L.LayerGroup) {
-        if (originalArray) {
-          layersArray = layersArray.slice();
-          originalArray = false;
-        }
-        this._extractNonGroupLayers(m, layersArray);
-        l = layersArray.length;
+    for (e = 0; e < n; e++) {
+      if (i = t[e], i instanceof u.LayerGroup) {
+        r && (t = t.slice(), r = !1), this._extractNonGroupLayers(i, t), n = t.length;
         continue;
       }
-      if (!m.__parent) {
-        npg.removeLayer(m);
-        this.fire("layerremove", { layer: m, propagatedFrom: m });
+      if (!i.__parent) {
+        o.removeLayer(i), this.fire("layerremove", { layer: i, propagatedFrom: i });
         continue;
       }
-      this._removeLayer(m, true, true);
-      this.fire("layerremove", { layer: m, propagatedFrom: m });
-      if (fg.hasLayer(m)) {
-        fg.removeLayer(m);
-        if (m.clusterShow) {
-          m.clusterShow();
-        }
-      }
+      this._removeLayer(i, !0, !0), this.fire("layerremove", { layer: i, propagatedFrom: i }), s.hasLayer(i) && (s.removeLayer(i), i.clusterShow && i.clusterShow());
     }
-    this._topClusterLevel._recalculateBounds();
-    this._refreshClustersIcons();
-    this._topClusterLevel._recursivelyAddChildrenToMap(
+    return this._topClusterLevel._recalculateBounds(), this._refreshClustersIcons(), this._topClusterLevel._recursivelyAddChildrenToMap(
       null,
       this._zoom,
       this._currentShownBounds
-    );
-    return this;
+    ), this;
   },
   //Removes all layers from the MarkerClusterGroup
   clearLayers: function() {
-    if (!this._map) {
-      this._needsClustering = [];
-      delete this._gridClusters;
-      delete this._gridUnclustered;
-    }
-    if (this._noanimationUnspiderfy) {
-      this._noanimationUnspiderfy();
-    }
-    this._featureGroup.clearLayers();
-    this._nonPointGroup.clearLayers();
-    this.eachLayer(function(marker) {
-      marker.off(this._childMarkerEventHandlers, this);
-      delete marker.__parent;
-    }, this);
-    if (this._map) {
-      this._generateInitialClusters();
-    }
-    return this;
+    return this._map || (this._needsClustering = [], delete this._gridClusters, delete this._gridUnclustered), this._noanimationUnspiderfy && this._noanimationUnspiderfy(), this._featureGroup.clearLayers(), this._nonPointGroup.clearLayers(), this.eachLayer(function(t) {
+      t.off(this._childMarkerEventHandlers, this), delete t.__parent;
+    }, this), this._map && this._generateInitialClusters(), this;
   },
   //Override FeatureGroup.getBounds as it doesn't work
   getBounds: function() {
-    var bounds = new L.LatLngBounds();
-    if (this._topClusterLevel) {
-      bounds.extend(this._topClusterLevel._bounds);
-    }
-    for (let i = this._needsClustering.length - 1; i >= 0; i--) {
-      bounds.extend(this._needsClustering[i].getLatLng());
-    }
-    bounds.extend(this._nonPointGroup.getBounds());
-    return bounds;
+    var t = new u.LatLngBounds();
+    this._topClusterLevel && t.extend(this._topClusterLevel._bounds);
+    for (let e = this._needsClustering.length - 1; e >= 0; e--)
+      t.extend(this._needsClustering[e].getLatLng());
+    return t.extend(this._nonPointGroup.getBounds()), t;
   },
   //Overrides LayerGroup.eachLayer
-  eachLayer: function(method, context) {
-    var markers = this._needsClustering.slice(), needsRemoving = this._needsRemoving, thisNeedsRemoving, i, j;
-    if (this._topClusterLevel) {
-      this._topClusterLevel.getAllChildMarkers(markers);
-    }
-    for (i = markers.length - 1; i >= 0; i--) {
-      thisNeedsRemoving = true;
-      for (j = needsRemoving.length - 1; j >= 0; j--) {
-        if (needsRemoving[j].layer === markers[i]) {
-          thisNeedsRemoving = false;
+  eachLayer: function(t, e) {
+    var i = this._needsClustering.slice(), n = this._needsRemoving, s, o, r;
+    for (this._topClusterLevel && this._topClusterLevel.getAllChildMarkers(i), o = i.length - 1; o >= 0; o--) {
+      for (s = !0, r = n.length - 1; r >= 0; r--)
+        if (n[r].layer === i[o]) {
+          s = !1;
           break;
         }
-      }
-      if (thisNeedsRemoving) {
-        method.call(context, markers[i]);
-      }
+      s && t.call(e, i[o]);
     }
-    this._nonPointGroup.eachLayer(method, context);
+    this._nonPointGroup.eachLayer(t, e);
   },
   //Overrides LayerGroup.getLayers
   getLayers: function() {
-    var layers = [];
-    this.eachLayer((l) => {
-      layers.push(l);
-    });
-    return layers;
+    var t = [];
+    return this.eachLayer((e) => {
+      t.push(e);
+    }), t;
   },
   //Overrides LayerGroup.getLayer, WARNING: Really bad performance
-  getLayer: function(id) {
-    var result = null;
-    id = parseInt(id, 10);
-    this.eachLayer((l) => {
-      if (L.stamp(l) === id) {
-        result = l;
-      }
-    });
-    return result;
+  getLayer: function(t) {
+    var e = null;
+    return t = parseInt(t, 10), this.eachLayer((i) => {
+      u.stamp(i) === t && (e = i);
+    }), e;
   },
   //Returns true if the given layer is in this MarkerClusterGroup
-  hasLayer: function(layer) {
-    if (!layer) {
-      return false;
-    }
-    var i, anArray = this._needsClustering;
-    for (i = anArray.length - 1; i >= 0; i--) {
-      if (anArray[i] === layer) {
-        return true;
-      }
-    }
-    anArray = this._needsRemoving;
-    for (i = anArray.length - 1; i >= 0; i--) {
-      if (anArray[i].layer === layer) {
-        return false;
-      }
-    }
-    return !!(layer.__parent && layer.__parent._group === this) || this._nonPointGroup.hasLayer(layer);
+  hasLayer: function(t) {
+    if (!t)
+      return !1;
+    var e, i = this._needsClustering;
+    for (e = i.length - 1; e >= 0; e--)
+      if (i[e] === t)
+        return !0;
+    for (i = this._needsRemoving, e = i.length - 1; e >= 0; e--)
+      if (i[e].layer === t)
+        return !1;
+    return !!(t.__parent && t.__parent._group === this) || this._nonPointGroup.hasLayer(t);
   },
   //Zoom down to show the given layer (spiderfying if necessary) then calls the callback
-  zoomToShowLayer: function(layer, callback) {
-    if (typeof callback !== "function") {
-      callback = () => {
-      };
-    }
-    var showMarker = function() {
-      if ((layer._icon || layer.__parent._icon) && !this._inZoomAnimation) {
-        this._map.off("moveend", showMarker, this);
-        this.off("animationend", showMarker, this);
-        if (layer._icon) {
-          callback();
-        } else if (layer.__parent._icon) {
-          this.once("spiderfied", callback, this);
-          layer.__parent.spiderfy();
-        }
-      }
+  zoomToShowLayer: function(t, e) {
+    typeof e != "function" && (e = () => {
+    });
+    var i = function() {
+      (t._icon || t.__parent._icon) && !this._inZoomAnimation && (this._map.off("moveend", i, this), this.off("animationend", i, this), t._icon ? e() : t.__parent._icon && (this.once("spiderfied", e, this), t.__parent.spiderfy()));
     };
-    if (layer._icon && this._map.getBounds().contains(layer.getLatLng())) {
-      callback();
-    } else if (layer.__parent._zoom < Math.round(this._map._zoom)) {
-      this._map.on("moveend", showMarker, this);
-      this._map.panTo(layer.getLatLng());
-    } else {
-      this._map.on("moveend", showMarker, this);
-      this.on("animationend", showMarker, this);
-      layer.__parent.zoomToBounds();
-    }
+    t._icon && this._map.getBounds().contains(t.getLatLng()) ? e() : t.__parent._zoom < Math.round(this._map._zoom) ? (this._map.on("moveend", i, this), this._map.panTo(t.getLatLng())) : (this._map.on("moveend", i, this), this.on("animationend", i, this), t.__parent.zoomToBounds());
   },
   //Overrides FeatureGroup.onAdd
-  onAdd: function(map) {
-    this._map = map;
-    var i, l, layer;
-    if (!Number.isFinite(this._map.getMaxZoom())) {
+  onAdd: function(t) {
+    this._map = t;
+    var e, i, n;
+    if (!Number.isFinite(this._map.getMaxZoom()))
       throw "Map has no maxZoom specified";
-    }
-    this._featureGroup.addTo(map);
-    this._nonPointGroup.addTo(map);
-    if (!this._gridClusters) {
-      this._generateInitialClusters();
-    }
-    this._maxLat = map.options.crs.projection.MAX_LATITUDE;
-    for (i = 0, l = this._needsRemoving.length; i < l; i++) {
-      layer = this._needsRemoving[i];
-      layer.newlatlng = layer.layer._latlng;
-      layer.layer._latlng = layer.latlng;
-    }
-    for (i = 0, l = this._needsRemoving.length; i < l; i++) {
-      layer = this._needsRemoving[i];
-      this._removeLayer(layer.layer, true);
-      layer.layer._latlng = layer.newlatlng;
-    }
-    this._needsRemoving = [];
-    this._zoom = Math.round(this._map._zoom);
-    this._currentShownBounds = this._getExpandedVisibleBounds();
-    this._map.on("zoomend", this._zoomEnd, this);
-    this._map.on("moveend", this._moveEnd, this);
-    if (this._spiderfierOnAdd) {
-      this._spiderfierOnAdd();
-    }
-    this._bindEvents();
-    l = this._needsClustering;
-    this._needsClustering = [];
-    this.addLayers(l, true);
+    for (this._featureGroup.addTo(t), this._nonPointGroup.addTo(t), this._gridClusters || this._generateInitialClusters(), this._maxLat = t.options.crs.projection.MAX_LATITUDE, e = 0, i = this._needsRemoving.length; e < i; e++)
+      n = this._needsRemoving[e], n.newlatlng = n.layer._latlng, n.layer._latlng = n.latlng;
+    for (e = 0, i = this._needsRemoving.length; e < i; e++)
+      n = this._needsRemoving[e], this._removeLayer(n.layer, !0), n.layer._latlng = n.newlatlng;
+    this._needsRemoving = [], this._zoom = Math.round(this._map._zoom), this._currentShownBounds = this._getExpandedVisibleBounds(), this._map.on("zoomend", this._zoomEnd, this), this._map.on("moveend", this._moveEnd, this), this._spiderfierOnAdd && this._spiderfierOnAdd(), this._bindEvents(), i = this._needsClustering, this._needsClustering = [], this.addLayers(i, !0);
   },
   //Overrides FeatureGroup.onRemove
-  onRemove: function(map) {
-    map.off("zoomend", this._zoomEnd, this);
-    map.off("moveend", this._moveEnd, this);
-    this._unbindEvents();
-    this._map._mapPane.className = this._map._mapPane.className.replace(
+  onRemove: function(t) {
+    t.off("zoomend", this._zoomEnd, this), t.off("moveend", this._moveEnd, this), this._unbindEvents(), this._map._mapPane.className = this._map._mapPane.className.replace(
       " leaflet-cluster-anim",
       ""
-    );
-    if (this._spiderfierOnRemove) {
-      this._spiderfierOnRemove();
-    }
-    delete this._maxLat;
-    this._hideCoverage();
-    this._featureGroup.remove();
-    this._nonPointGroup.remove();
-    this._featureGroup.clearLayers();
-    this._map = null;
-  },
-  getVisibleParent: (marker) => {
-    var vMarker = marker;
-    while (vMarker && !vMarker._icon) {
-      vMarker = vMarker.__parent;
-    }
-    return vMarker || null;
+    ), this._spiderfierOnRemove && this._spiderfierOnRemove(), delete this._maxLat, this._hideCoverage(), this._featureGroup.remove(), this._nonPointGroup.remove(), this._featureGroup.clearLayers(), this._map = null;
+  },
+  getVisibleParent: (t) => {
+    for (var e = t; e && !e._icon; )
+      e = e.__parent;
+    return e || null;
   },
   //Remove the given object from the given array
-  _arraySplice: (anArray, obj) => {
-    for (let i = anArray.length - 1; i >= 0; i--) {
-      if (anArray[i] === obj) {
-        anArray.splice(i, 1);
-        return true;
-      }
-    }
+  _arraySplice: (t, e) => {
+    for (let i = t.length - 1; i >= 0; i--)
+      if (t[i] === e)
+        return t.splice(i, 1), !0;
   },
   /**
    * Removes a marker from all _gridUnclustered zoom levels, starting at the supplied zoom.
@@ -492,269 +246,157 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
    * @param z integer bottom start zoom level (included)
    * @private
    */
-  _removeFromGridUnclustered: function(marker, z) {
-    var map = this._map, gridUnclustered = this._gridUnclustered, minZoom = Math.floor(this._map.getMinZoom());
-    for (; z >= minZoom; z--) {
-      if (!gridUnclustered[z].removeObject(
-        marker,
-        map.project(marker.getLatLng(), z)
-      )) {
-        break;
-      }
-    }
+  _removeFromGridUnclustered: function(t, e) {
+    for (var i = this._map, n = this._gridUnclustered, s = Math.floor(this._map.getMinZoom()); e >= s && n[e].removeObject(
+      t,
+      i.project(t.getLatLng(), e)
+    ); e--)
+      ;
   },
-  _childMarkerDragStart: (e) => {
-    e.target.__dragStart = e.target._latlng;
+  _childMarkerDragStart: (t) => {
+    t.target.__dragStart = t.target._latlng;
   },
-  _childMarkerMoved: function(e) {
-    if (!this._ignoreMove && !e.target.__dragStart) {
-      const isPopupOpen = (e.target._popup || null)?.isOpen();
-      this._moveChild(e.target, e.oldLatLng, e.latlng);
-      if (isPopupOpen) {
-        e.target.openPopup();
-      }
+  _childMarkerMoved: function(t) {
+    if (!this._ignoreMove && !t.target.__dragStart) {
+      const e = (t.target._popup || null)?.isOpen();
+      this._moveChild(t.target, t.oldLatLng, t.latlng), e && t.target.openPopup();
     }
   },
-  _moveChild: function(layer, from, to) {
-    layer._latlng = from;
-    this.removeLayer(layer);
-    layer._latlng = to;
-    this.addLayer(layer);
+  _moveChild: function(t, e, i) {
+    t._latlng = e, this.removeLayer(t), t._latlng = i, this.addLayer(t);
   },
-  _childMarkerDragEnd: function(e) {
-    if (e.target.__dragStart) {
-      this._moveChild(e.target, e.target.__dragStart, e.target._latlng);
-    }
-    delete e.target.__dragStart;
+  _childMarkerDragEnd: function(t) {
+    t.target.__dragStart && this._moveChild(t.target, t.target.__dragStart, t.target._latlng), delete t.target.__dragStart;
   },
   //Internal function for removing a marker from everything.
   //dontUpdateMap: set to true if you will handle updating the map manually (for bulk functions)
-  _removeLayer: function(marker, removeFromDistanceGrid, dontUpdateMap) {
-    var gridClusters = this._gridClusters, gridUnclustered = this._gridUnclustered, fg = this._featureGroup, map = this._map, minZoom = Math.floor(this._map.getMinZoom());
-    if (removeFromDistanceGrid) {
-      this._removeFromGridUnclustered(marker, this._maxZoom);
-    }
-    var cluster = marker.__parent, markers = cluster._markers, otherMarker;
-    this._arraySplice(markers, marker);
-    while (cluster) {
-      cluster._childCount--;
-      cluster._boundsNeedUpdate = true;
-      if (cluster._zoom < minZoom) {
-        break;
-      } else if (removeFromDistanceGrid && cluster._childCount <= 1) {
-        otherMarker = cluster._markers[0] === marker ? cluster._markers[1] : cluster._markers[0];
-        gridClusters[cluster._zoom].removeObject(
-          cluster,
-          map.project(cluster._cLatLng, cluster._zoom)
-        );
-        gridUnclustered[cluster._zoom].addObject(
-          otherMarker,
-          map.project(otherMarker.getLatLng(), cluster._zoom)
-        );
-        this._arraySplice(cluster.__parent._childClusters, cluster);
-        cluster.__parent._markers.push(otherMarker);
-        otherMarker.__parent = cluster.__parent;
-        if (cluster._icon) {
-          fg.removeLayer(cluster);
-          if (!dontUpdateMap) {
-            fg.addLayer(otherMarker);
-          }
-        }
-      } else {
-        cluster._iconNeedsUpdate = true;
-      }
-      cluster = cluster.__parent;
-    }
-    delete marker.__parent;
-  },
-  _isOrIsParent: (el, oel) => {
-    while (oel) {
-      if (el === oel) return true;
-      oel = oel.parentNode;
-    }
-    return false;
+  _removeLayer: function(t, e, i) {
+    var n = this._gridClusters, s = this._gridUnclustered, o = this._featureGroup, r = this._map, a = Math.floor(this._map.getMinZoom());
+    e && this._removeFromGridUnclustered(t, this._maxZoom);
+    var h = t.__parent, _ = h._markers, l;
+    for (this._arraySplice(_, t); h && (h._childCount--, h._boundsNeedUpdate = !0, !(h._zoom < a)); )
+      e && h._childCount <= 1 ? (l = h._markers[0] === t ? h._markers[1] : h._markers[0], n[h._zoom].removeObject(
+        h,
+        r.project(h._cLatLng, h._zoom)
+      ), s[h._zoom].addObject(
+        l,
+        r.project(l.getLatLng(), h._zoom)
+      ), this._arraySplice(h.__parent._childClusters, h), h.__parent._markers.push(l), l.__parent = h.__parent, h._icon && (o.removeLayer(h), i || o.addLayer(l))) : h._iconNeedsUpdate = !0, h = h.__parent;
+    delete t.__parent;
+  },
+  _isOrIsParent: (t, e) => {
+    for (; e; ) {
+      if (t === e) return !0;
+      e = e.parentNode;
+    }
+    return !1;
   },
   //Override L.Evented.fire
-  fire: function(type, e, propagate) {
-    if (e && e.propagatedFrom instanceof L.MarkerCluster) {
+  fire: function(t, e, i) {
+    if (e && e.propagatedFrom instanceof u.MarkerCluster) {
       if (e.originalEvent && this._isOrIsParent(
         e.propagatedFrom._icon,
         e.originalEvent.relatedTarget
       ))
         return;
-      type = `cluster${type}`;
+      t = `cluster${t}`;
     }
-    L.FeatureGroup.prototype.fire.call(this, type, e, propagate);
+    u.FeatureGroup.prototype.fire.call(this, t, e, i);
   },
   //Override L.Evented.listens
-  listens: function(type, propagate) {
-    return L.FeatureGroup.prototype.listens.call(this, type, propagate) || L.FeatureGroup.prototype.listens.call(this, `cluster${type}`, propagate);
+  listens: function(t, e) {
+    return u.FeatureGroup.prototype.listens.call(this, t, e) || u.FeatureGroup.prototype.listens.call(this, `cluster${t}`, e);
   },
   //Default functionality
-  _defaultIconCreateFunction: (cluster) => {
-    const childCount = cluster.getChildCount();
-    let c = " marker-cluster-";
-    if (childCount < 10) {
-      c += "small";
-    } else if (childCount < 100) {
-      c += "medium";
-    } else {
-      c += "large";
-    }
-    return new L.DivIcon({
-      html: `<div><span>${childCount}</span></div>`,
-      className: `marker-cluster ${c}`,
-      iconSize: new L.Point(40, 40)
+  _defaultIconCreateFunction: (t) => {
+    const e = t.getChildCount();
+    let i = " marker-cluster-";
+    return e < 10 ? i += "small" : e < 100 ? i += "medium" : i += "large", new u.DivIcon({
+      html: `<div><span>${e}</span></div>`,
+      className: `marker-cluster ${i}`,
+      iconSize: new u.Point(40, 40)
     });
   },
   _bindEvents: function() {
-    var map = this._map, spiderfyOnMaxZoom = this.options.spiderfyOnMaxZoom, showCoverageOnHover = this.options.showCoverageOnHover, zoomToBoundsOnClick = this.options.zoomToBoundsOnClick;
-    if (spiderfyOnMaxZoom || zoomToBoundsOnClick) {
-      this.on("clusterclick", this._zoomOrSpiderfy, this);
-    }
-    if (showCoverageOnHover) {
-      this.on("clustermouseover", this._showCoverage, this);
-      this.on("clustermouseout", this._hideCoverage, this);
-      map.on("zoomend", this._hideCoverage, this);
-    }
-  },
-  _zoomOrSpiderfy: function(e) {
-    const cluster = e.propagatedFrom;
-    let bottomCluster = cluster;
-    while (bottomCluster._childClusters.length === 1) {
-      bottomCluster = bottomCluster._childClusters[0];
-    }
-    if (bottomCluster._zoom === this._maxZoom && bottomCluster._childCount === cluster._childCount && this.options.spiderfyOnMaxZoom) {
-      cluster.spiderfy();
-    } else if (this.options.zoomToBoundsOnClick) {
-      cluster.zoomToBounds();
-    }
-    if (e.originalEvent && e.originalEvent.keyCode === 13) {
-      this._map._container.focus();
-    }
-  },
-  _showCoverage: function(e) {
-    var map = this._map;
-    if (this._inZoomAnimation) {
-      return;
-    }
-    if (this._shownPolygon) {
-      map.removeLayer(this._shownPolygon);
-    }
-    if (e.propagatedFrom.getChildCount() > 2 && e.propagatedFrom !== this._spiderfied) {
-      this._shownPolygon = new L.Polygon(
-        e.propagatedFrom.getConvexHull(),
-        this.options.polygonOptions
-      );
-      map.addLayer(this._shownPolygon);
-    }
+    var t = this._map, e = this.options.spiderfyOnMaxZoom, i = this.options.showCoverageOnHover, n = this.options.zoomToBoundsOnClick;
+    (e || n) && this.on("clusterclick", this._zoomOrSpiderfy, this), i && (this.on("clustermouseover", this._showCoverage, this), this.on("clustermouseout", this._hideCoverage, this), t.on("zoomend", this._hideCoverage, this));
+  },
+  _zoomOrSpiderfy: function(t) {
+    const e = t.propagatedFrom;
+    let i = e;
+    for (; i._childClusters.length === 1; )
+      i = i._childClusters[0];
+    i._zoom === this._maxZoom && i._childCount === e._childCount && this.options.spiderfyOnMaxZoom ? e.spiderfy() : this.options.zoomToBoundsOnClick && e.zoomToBounds(), t.originalEvent && t.originalEvent.keyCode === 13 && this._map._container.focus();
+  },
+  _showCoverage: function(t) {
+    var e = this._map;
+    this._inZoomAnimation || (this._shownPolygon && e.removeLayer(this._shownPolygon), t.propagatedFrom.getChildCount() > 2 && t.propagatedFrom !== this._spiderfied && (this._shownPolygon = new u.Polygon(
+      t.propagatedFrom.getConvexHull(),
+      this.options.polygonOptions
+    ), e.addLayer(this._shownPolygon)));
   },
   _hideCoverage: function() {
-    if (this._shownPolygon) {
-      this._map.removeLayer(this._shownPolygon);
-      this._shownPolygon = null;
-    }
+    this._shownPolygon && (this._map.removeLayer(this._shownPolygon), this._shownPolygon = null);
   },
   _unbindEvents: function() {
-    var spiderfyOnMaxZoom = this.options.spiderfyOnMaxZoom, showCoverageOnHover = this.options.showCoverageOnHover, zoomToBoundsOnClick = this.options.zoomToBoundsOnClick, map = this._map;
-    if (spiderfyOnMaxZoom || zoomToBoundsOnClick) {
-      this.off("clusterclick", this._zoomOrSpiderfy, this);
-    }
-    if (showCoverageOnHover) {
-      this.off("clustermouseover", this._showCoverage, this);
-      this.off("clustermouseout", this._hideCoverage, this);
-      map.off("zoomend", this._hideCoverage, this);
-    }
+    var t = this.options.spiderfyOnMaxZoom, e = this.options.showCoverageOnHover, i = this.options.zoomToBoundsOnClick, n = this._map;
+    (t || i) && this.off("clusterclick", this._zoomOrSpiderfy, this), e && (this.off("clustermouseover", this._showCoverage, this), this.off("clustermouseout", this._hideCoverage, this), n.off("zoomend", this._hideCoverage, this));
   },
   _zoomEnd: function() {
-    if (!this._map) {
-      return;
-    }
-    this._mergeSplitClusters();
-    this._zoom = Math.round(this._map._zoom);
-    this._currentShownBounds = this._getExpandedVisibleBounds();
+    this._map && (this._mergeSplitClusters(), this._zoom = Math.round(this._map._zoom), this._currentShownBounds = this._getExpandedVisibleBounds());
   },
   _moveEnd: function() {
-    if (this._inZoomAnimation) {
-      return;
+    if (!this._inZoomAnimation) {
+      var t = this._getExpandedVisibleBounds();
+      this._topClusterLevel._recursivelyRemoveChildrenFromMap(
+        this._currentShownBounds,
+        Math.floor(this._map.getMinZoom()),
+        this._zoom,
+        t
+      ), this._topClusterLevel._recursivelyAddChildrenToMap(
+        null,
+        Math.round(this._map._zoom),
+        t
+      ), this._currentShownBounds = t;
     }
-    var newBounds = this._getExpandedVisibleBounds();
-    this._topClusterLevel._recursivelyRemoveChildrenFromMap(
-      this._currentShownBounds,
-      Math.floor(this._map.getMinZoom()),
-      this._zoom,
-      newBounds
-    );
-    this._topClusterLevel._recursivelyAddChildrenToMap(
-      null,
-      Math.round(this._map._zoom),
-      newBounds
-    );
-    this._currentShownBounds = newBounds;
-    return;
   },
   _generateInitialClusters: function() {
-    var maxZoom = Math.ceil(this._map.getMaxZoom()), minZoom = Math.floor(this._map.getMinZoom()), radius = this.options.maxClusterRadius, radiusFn = radius;
-    if (typeof radius !== "function") {
-      radiusFn = () => radius;
-    }
-    if (this.options.disableClusteringAtZoom !== null) {
-      maxZoom = this.options.disableClusteringAtZoom - 1;
-    }
-    this._maxZoom = maxZoom;
-    this._gridClusters = {};
-    this._gridUnclustered = {};
-    for (let zoom = maxZoom; zoom >= minZoom; zoom--) {
-      this._gridClusters[zoom] = new L.DistanceGrid(radiusFn(zoom));
-      this._gridUnclustered[zoom] = new L.DistanceGrid(radiusFn(zoom));
-    }
-    this._topClusterLevel = new this._markerCluster(this, minZoom - 1);
+    var t = Math.ceil(this._map.getMaxZoom()), e = Math.floor(this._map.getMinZoom()), i = this.options.maxClusterRadius, n = i;
+    typeof i != "function" && (n = () => i), this.options.disableClusteringAtZoom !== null && (t = this.options.disableClusteringAtZoom - 1), this._maxZoom = t, this._gridClusters = {}, this._gridUnclustered = {};
+    for (let s = t; s >= e; s--)
+      this._gridClusters[s] = new u.DistanceGrid(n(s)), this._gridUnclustered[s] = new u.DistanceGrid(n(s));
+    this._topClusterLevel = new this._markerCluster(this, e - 1);
   },
   //Zoom: Zoom to start adding at (Pass this._maxZoom to start at the bottom)
-  _addLayer: function(layer, zoom) {
-    var gridClusters = this._gridClusters, gridUnclustered = this._gridUnclustered, minZoom = Math.floor(this._map.getMinZoom()), markerPoint, z;
-    if (this.options.singleMarkerMode) {
-      this._overrideMarkerIcon(layer);
-    }
-    layer.on(this._childMarkerEventHandlers, this);
-    for (; zoom >= minZoom; zoom--) {
-      markerPoint = this._map.project(layer.getLatLng(), zoom);
-      let closest = gridClusters[zoom].getNearObject(markerPoint);
-      if (closest) {
-        closest._addChild(layer);
-        layer.__parent = closest;
+  _addLayer: function(t, e) {
+    var i = this._gridClusters, n = this._gridUnclustered, s = Math.floor(this._map.getMinZoom()), o, r;
+    for (this.options.singleMarkerMode && this._overrideMarkerIcon(t), t.on(this._childMarkerEventHandlers, this); e >= s; e--) {
+      o = this._map.project(t.getLatLng(), e);
+      let a = i[e].getNearObject(o);
+      if (a) {
+        a._addChild(t), t.__parent = a;
         return;
       }
-      closest = gridUnclustered[zoom].getNearObject(markerPoint);
-      if (closest) {
-        const parent = closest.__parent;
-        if (parent) {
-          this._removeLayer(closest, false);
-        }
-        const newCluster = new this._markerCluster(this, zoom, closest, layer);
-        gridClusters[zoom].addObject(
-          newCluster,
-          this._map.project(newCluster._cLatLng, zoom)
-        );
-        closest.__parent = newCluster;
-        layer.__parent = newCluster;
-        let lastParent = newCluster;
-        for (z = zoom - 1; z > parent._zoom; z--) {
-          lastParent = new this._markerCluster(this, z, lastParent);
-          gridClusters[z].addObject(
-            lastParent,
-            this._map.project(closest.getLatLng(), z)
+      if (a = n[e].getNearObject(o), a) {
+        const h = a.__parent;
+        h && this._removeLayer(a, !1);
+        const _ = new this._markerCluster(this, e, a, t);
+        i[e].addObject(
+          _,
+          this._map.project(_._cLatLng, e)
+        ), a.__parent = _, t.__parent = _;
+        let l = _;
+        for (r = e - 1; r > h._zoom; r--)
+          l = new this._markerCluster(this, r, l), i[r].addObject(
+            l,
+            this._map.project(a.getLatLng(), r)
           );
-        }
-        parent._addChild(lastParent);
-        this._removeFromGridUnclustered(closest, zoom);
+        h._addChild(l), this._removeFromGridUnclustered(a, e);
         return;
       }
-      gridUnclustered[zoom].addObject(layer, markerPoint);
+      n[e].addObject(t, o);
     }
-    this._topClusterLevel._addChild(layer);
-    layer.__parent = this._topClusterLevel;
-    return;
+    this._topClusterLevel._addChild(t), t.__parent = this._topClusterLevel;
   },
   /**
    * Refreshes the icon of all "dirty" visible clusters.
@@ -762,54 +404,35 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
    * @private
    */
   _refreshClustersIcons: function() {
-    this._featureGroup.eachLayer((c) => {
-      if (c instanceof L.MarkerCluster && c._iconNeedsUpdate) {
-        c._updateIcon();
-      }
+    this._featureGroup.eachLayer((t) => {
+      t instanceof u.MarkerCluster && t._iconNeedsUpdate && t._updateIcon();
     });
   },
   //Enqueue code to fire after the marker expand/contract has happened
-  _enqueue: function(fn) {
-    this._queue.push(fn);
-    if (!this._queueTimeout) {
-      this._queueTimeout = setTimeout(() => this._processQueue(), 300);
-    }
+  _enqueue: function(t) {
+    this._queue.push(t), this._queueTimeout || (this._queueTimeout = setTimeout(() => this._processQueue(), 300));
   },
   _processQueue: function() {
-    for (let i = 0; i < this._queue.length; i++) {
-      this._queue[i].call(this);
-    }
-    this._queue.length = 0;
-    clearTimeout(this._queueTimeout);
-    this._queueTimeout = null;
+    for (let t = 0; t < this._queue.length; t++)
+      this._queue[t].call(this);
+    this._queue.length = 0, clearTimeout(this._queueTimeout), this._queueTimeout = null;
   },
   //Merge and split any existing clusters that are too big or small
   _mergeSplitClusters: function() {
-    var mapZoom = Math.round(this._map._zoom);
-    this._processQueue();
-    if (this._zoom < mapZoom && this._currentShownBounds.intersects(this._getExpandedVisibleBounds())) {
-      this._animationStart();
-      this._topClusterLevel._recursivelyRemoveChildrenFromMap(
-        this._currentShownBounds,
-        Math.floor(this._map.getMinZoom()),
-        this._zoom,
-        this._getExpandedVisibleBounds()
-      );
-      this._animationZoomIn(this._zoom, mapZoom);
-    } else if (this._zoom > mapZoom) {
-      this._animationStart();
-      this._animationZoomOut(this._zoom, mapZoom);
-    } else {
-      this._moveEnd();
-    }
+    var t = Math.round(this._map._zoom);
+    this._processQueue(), this._zoom < t && this._currentShownBounds.intersects(this._getExpandedVisibleBounds()) ? (this._animationStart(), this._topClusterLevel._recursivelyRemoveChildrenFromMap(
+      this._currentShownBounds,
+      Math.floor(this._map.getMinZoom()),
+      this._zoom,
+      this._getExpandedVisibleBounds()
+    ), this._animationZoomIn(this._zoom, t)) : this._zoom > t ? (this._animationStart(), this._animationZoomOut(this._zoom, t)) : this._moveEnd();
   },
   //Gets the maps visible bounds expanded in each direction by the size of the screen (so the user cannot see an area we do not cover in one pan)
   _getExpandedVisibleBounds: function() {
-    if (!this.options.removeOutsideVisibleBounds) {
-      return this._mapBoundsInfinite;
-    } else if (L.Browser.mobile) {
-      return this._checkBoundsMaxLat(this._map.getBounds());
-    }
+    if (this.options.removeOutsideVisibleBounds) {
+      if (u.Browser.mobile)
+        return this._checkBoundsMaxLat(this._map.getBounds());
+    } else return this._mapBoundsInfinite;
     return this._checkBoundsMaxLat(this._map.getBounds().pad(1));
   },
   /**
@@ -822,30 +445,20 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
    * @returns {L.LatLngBounds}
    * @private
    */
-  _checkBoundsMaxLat: function(bounds) {
-    var maxLat = this._maxLat;
-    if (maxLat !== void 0) {
-      if (bounds.getNorth() >= maxLat) {
-        bounds._northEast.lat = Infinity;
-      }
-      if (bounds.getSouth() <= -maxLat) {
-        bounds._southWest.lat = -Infinity;
-      }
-    }
-    return bounds;
+  _checkBoundsMaxLat: function(t) {
+    var e = this._maxLat;
+    return e !== void 0 && (t.getNorth() >= e && (t._northEast.lat = 1 / 0), t.getSouth() <= -e && (t._southWest.lat = -1 / 0)), t;
   },
   //Shared animation code
-  _animationAddLayerNonAnimated: function(layer, newCluster) {
-    if (newCluster === layer) {
-      this._featureGroup.addLayer(layer);
-    } else if (newCluster._childCount === 2) {
-      newCluster._addToMap();
-      const markers = newCluster.getAllChildMarkers();
-      this._featureGroup.removeLayer(markers[0]);
-      this._featureGroup.removeLayer(markers[1]);
-    } else {
-      newCluster._updateIcon();
-    }
+  _animationAddLayerNonAnimated: function(t, e) {
+    if (e === t)
+      this._featureGroup.addLayer(t);
+    else if (e._childCount === 2) {
+      e._addToMap();
+      const i = e.getAllChildMarkers();
+      this._featureGroup.removeLayer(i[0]), this._featureGroup.removeLayer(i[1]);
+    } else
+      e._updateIcon();
   },
   /**
    * Extracts individual (i.e. non-group) layers from a Layer Group.
@@ -854,18 +467,16 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
    * @returns {*|Array}
    * @private
    */
-  _extractNonGroupLayers: function(group, output) {
-    var layers = group.getLayers(), i = 0, layer;
-    output = output || [];
-    for (; i < layers.length; i++) {
-      layer = layers[i];
-      if (layer instanceof L.LayerGroup) {
-        this._extractNonGroupLayers(layer, output);
+  _extractNonGroupLayers: function(t, e) {
+    var i = t.getLayers(), n = 0, s;
+    for (e = e || []; n < i.length; n++) {
+      if (s = i[n], s instanceof u.LayerGroup) {
+        this._extractNonGroupLayers(s, e);
         continue;
       }
-      output.push(layer);
+      e.push(s);
     }
-    return output;
+    return e;
   },
   /**
    * Implements the singleMarkerMode option.
@@ -873,318 +484,206 @@ L.MarkerClusterGroup = L.FeatureGroup.extend({
    * @returns {L.Icon} The newly created icon.
    * @private
    */
-  _overrideMarkerIcon: function(layer) {
-    layer.options.icon = this.options.iconCreateFunction({
+  _overrideMarkerIcon: function(t) {
+    return t.options.icon = this.options.iconCreateFunction({
       getChildCount: () => 1,
-      getAllChildMarkers: () => [layer]
-    });
-    return layer.options.icon;
+      getAllChildMarkers: () => [t]
+    }), t.options.icon;
   }
 });
-L.MarkerClusterGroup.include({
-  _mapBoundsInfinite: new L.LatLngBounds(
-    new L.LatLng(-Infinity, -Infinity),
-    new L.LatLng(Infinity, Infinity)
+u.MarkerClusterGroup.include({
+  _mapBoundsInfinite: new u.LatLngBounds(
+    new u.LatLng(-1 / 0, -1 / 0),
+    new u.LatLng(1 / 0, 1 / 0)
   )
 });
-L.MarkerClusterGroup.include({
+u.MarkerClusterGroup.include({
   _noAnimation: {
     //Non Animated versions of everything
     _animationStart: () => {
     },
-    _animationZoomIn: function(previousZoomLevel, newZoomLevel) {
+    _animationZoomIn: function(t, e) {
       this._topClusterLevel._recursivelyRemoveChildrenFromMap(
         this._currentShownBounds,
         Math.floor(this._map.getMinZoom()),
-        previousZoomLevel
-      );
-      this._topClusterLevel._recursivelyAddChildrenToMap(
+        t
+      ), this._topClusterLevel._recursivelyAddChildrenToMap(
         null,
-        newZoomLevel,
+        e,
         this._getExpandedVisibleBounds()
-      );
-      this.fire("animationend");
+      ), this.fire("animationend");
     },
-    _animationZoomOut: function(previousZoomLevel, newZoomLevel) {
+    _animationZoomOut: function(t, e) {
       this._topClusterLevel._recursivelyRemoveChildrenFromMap(
         this._currentShownBounds,
         Math.floor(this._map.getMinZoom()),
-        previousZoomLevel
-      );
-      this._topClusterLevel._recursivelyAddChildrenToMap(
+        t
+      ), this._topClusterLevel._recursivelyAddChildrenToMap(
         null,
-        newZoomLevel,
+        e,
         this._getExpandedVisibleBounds()
-      );
-      this.fire("animationend");
+      ), this.fire("animationend");
     },
-    _animationAddLayer: function(layer, newCluster) {
-      this._animationAddLayerNonAnimated(layer, newCluster);
+    _animationAddLayer: function(t, e) {
+      this._animationAddLayerNonAnimated(t, e);
     }
   },
   _withAnimation: {
     //Animated versions here
     _animationStart: function() {
-      this._map._mapPane.className += " leaflet-cluster-anim";
-      this._inZoomAnimation++;
+      this._map._mapPane.className += " leaflet-cluster-anim", this._inZoomAnimation++;
     },
-    _animationZoomIn: function(previousZoomLevel, newZoomLevel) {
-      var bounds = this._getExpandedVisibleBounds(), fg = this._featureGroup, minZoom = Math.floor(this._map.getMinZoom()), i;
-      this._ignoreMove = true;
-      this._topClusterLevel._recursively(
-        bounds,
-        previousZoomLevel,
-        minZoom,
-        (c) => {
-          var startPos = c._latlng, markers = c._markers, m;
-          if (!bounds.contains(startPos)) {
-            startPos = null;
-          }
-          if (c._isSingleParent() && previousZoomLevel + 1 === newZoomLevel) {
-            fg.removeLayer(c);
-            c._recursivelyAddChildrenToMap(null, newZoomLevel, bounds);
-          } else {
-            c.clusterHide();
-            c._recursivelyAddChildrenToMap(startPos, newZoomLevel, bounds);
-          }
-          for (i = markers.length - 1; i >= 0; i--) {
-            m = markers[i];
-            if (!bounds.contains(m._latlng)) {
-              fg.removeLayer(m);
-            }
-          }
+    _animationZoomIn: function(t, e) {
+      var i = this._getExpandedVisibleBounds(), n = this._featureGroup, s = Math.floor(this._map.getMinZoom()), o;
+      this._ignoreMove = !0, this._topClusterLevel._recursively(
+        i,
+        t,
+        s,
+        (r) => {
+          var a = r._latlng, h = r._markers, _;
+          for (i.contains(a) || (a = null), r._isSingleParent() && t + 1 === e ? (n.removeLayer(r), r._recursivelyAddChildrenToMap(null, e, i)) : (r.clusterHide(), r._recursivelyAddChildrenToMap(a, e, i)), o = h.length - 1; o >= 0; o--)
+            _ = h[o], i.contains(_._latlng) || n.removeLayer(_);
         }
-      );
-      this._forceLayout();
-      this._topClusterLevel._recursivelyBecomeVisible(bounds, newZoomLevel);
-      fg.eachLayer((n) => {
-        if (!(n instanceof L.MarkerCluster) && n._icon) {
-          n.clusterShow();
+      ), this._forceLayout(), this._topClusterLevel._recursivelyBecomeVisible(i, e), n.eachLayer((r) => {
+        !(r instanceof u.MarkerCluster) && r._icon && r.clusterShow();
+      }), this._topClusterLevel._recursively(
+        i,
+        t,
+        e,
+        (r) => {
+          r._recursivelyRestoreChildPositions(e);
         }
-      });
-      this._topClusterLevel._recursively(
-        bounds,
-        previousZoomLevel,
-        newZoomLevel,
-        (c) => {
-          c._recursivelyRestoreChildPositions(newZoomLevel);
-        }
-      );
-      this._ignoreMove = false;
-      this._enqueue(function() {
+      ), this._ignoreMove = !1, this._enqueue(function() {
         this._topClusterLevel._recursively(
-          bounds,
-          previousZoomLevel,
-          minZoom,
-          (c) => {
-            fg.removeLayer(c);
-            c.clusterShow();
+          i,
+          t,
+          s,
+          (r) => {
+            n.removeLayer(r), r.clusterShow();
           }
-        );
-        this._animationEnd();
+        ), this._animationEnd();
       });
     },
-    _animationZoomOut: function(previousZoomLevel, newZoomLevel) {
+    _animationZoomOut: function(t, e) {
       this._animationZoomOutSingle(
         this._topClusterLevel,
-        previousZoomLevel - 1,
-        newZoomLevel
-      );
-      this._topClusterLevel._recursivelyAddChildrenToMap(
+        t - 1,
+        e
+      ), this._topClusterLevel._recursivelyAddChildrenToMap(
         null,
-        newZoomLevel,
+        e,
         this._getExpandedVisibleBounds()
-      );
-      this._topClusterLevel._recursivelyRemoveChildrenFromMap(
+      ), this._topClusterLevel._recursivelyRemoveChildrenFromMap(
         this._currentShownBounds,
         Math.floor(this._map.getMinZoom()),
-        previousZoomLevel,
+        t,
         this._getExpandedVisibleBounds()
       );
     },
-    _animationAddLayer: function(layer, newCluster) {
-      var fg = this._featureGroup;
-      fg.addLayer(layer);
-      if (newCluster !== layer) {
-        if (newCluster._childCount > 2) {
-          newCluster._updateIcon();
-          this._forceLayout();
-          this._animationStart();
-          layer._setPos(this._map.latLngToLayerPoint(newCluster.getLatLng()));
-          layer.clusterHide();
-          this._enqueue(() => {
-            fg.removeLayer(layer);
-            layer.clusterShow();
-            this._animationEnd();
-          });
-        } else {
-          this._forceLayout();
-          this._animationStart();
-          this._animationZoomOutSingle(
-            newCluster,
-            this._map.getMaxZoom(),
-            this._zoom
-          );
-        }
-      }
+    _animationAddLayer: function(t, e) {
+      var i = this._featureGroup;
+      i.addLayer(t), e !== t && (e._childCount > 2 ? (e._updateIcon(), this._forceLayout(), this._animationStart(), t._setPos(this._map.latLngToLayerPoint(e.getLatLng())), t.clusterHide(), this._enqueue(() => {
+        i.removeLayer(t), t.clusterShow(), this._animationEnd();
+      })) : (this._forceLayout(), this._animationStart(), this._animationZoomOutSingle(
+        e,
+        this._map.getMaxZoom(),
+        this._zoom
+      )));
     }
   },
   // Private methods for animated versions.
-  _animationZoomOutSingle: function(cluster, previousZoomLevel, newZoomLevel) {
-    var bounds = this._getExpandedVisibleBounds(), minZoom = Math.floor(this._map.getMinZoom());
-    cluster._recursivelyAnimateChildrenInAndAddSelfToMap(
-      bounds,
-      minZoom,
-      previousZoomLevel + 1,
-      newZoomLevel
+  _animationZoomOutSingle: function(t, e, i) {
+    var n = this._getExpandedVisibleBounds(), s = Math.floor(this._map.getMinZoom());
+    t._recursivelyAnimateChildrenInAndAddSelfToMap(
+      n,
+      s,
+      e + 1,
+      i
     );
-    var me = this;
-    this._forceLayout();
-    cluster._recursivelyBecomeVisible(bounds, newZoomLevel);
-    this._enqueue(function() {
-      if (cluster._childCount === 1) {
-        const m = cluster._markers[0];
-        this._ignoreMove = true;
-        m.setLatLng(m.getLatLng());
-        this._ignoreMove = false;
-        if (m.clusterShow) {
-          m.clusterShow();
-        }
-      } else {
-        cluster._recursively(bounds, newZoomLevel, minZoom, (c) => {
-          c._recursivelyRemoveChildrenFromMap(
-            bounds,
-            minZoom,
-            previousZoomLevel + 1
+    var o = this;
+    this._forceLayout(), t._recursivelyBecomeVisible(n, i), this._enqueue(function() {
+      if (t._childCount === 1) {
+        const r = t._markers[0];
+        this._ignoreMove = !0, r.setLatLng(r.getLatLng()), this._ignoreMove = !1, r.clusterShow && r.clusterShow();
+      } else
+        t._recursively(n, i, s, (r) => {
+          r._recursivelyRemoveChildrenFromMap(
+            n,
+            s,
+            e + 1
           );
         });
-      }
-      me._animationEnd();
+      o._animationEnd();
     });
   },
   _animationEnd: function() {
-    if (this._map) {
-      this._map._mapPane.className = this._map._mapPane.className.replace(
-        " leaflet-cluster-anim",
-        ""
-      );
-    }
-    this._inZoomAnimation--;
-    this.fire("animationend");
+    this._map && (this._map._mapPane.className = this._map._mapPane.className.replace(
+      " leaflet-cluster-anim",
+      ""
+    )), this._inZoomAnimation--, this.fire("animationend");
   },
   //Force a browser layout of stuff in the map
   // Should apply the current opacity and location to all elements so we can update them again for an animation
   _forceLayout: () => {
-    L.Util.falseFn(document.body.offsetWidth);
+    u.Util.falseFn(document.body.offsetWidth);
   }
 });
-L.MarkerCluster = L.Marker.extend({
-  initialize: function(group, zoom, a, b) {
-    L.Marker.prototype.initialize.call(
+u.MarkerCluster = u.Marker.extend({
+  initialize: function(t, e, i, n) {
+    u.Marker.prototype.initialize.call(
       this,
-      a ? a._cLatLng || a.getLatLng() : new L.LatLng(0, 0),
-      { icon: this, pane: group.options.clusterPane }
-    );
-    this._group = group;
-    this._zoom = zoom;
-    this._markers = [];
-    this._childClusters = [];
-    this._childCount = 0;
-    this._iconNeedsUpdate = true;
-    this._boundsNeedUpdate = true;
-    this._bounds = new L.LatLngBounds();
-    if (a) {
-      this._addChild(a);
-    }
-    if (b) {
-      this._addChild(b);
-    }
+      i ? i._cLatLng || i.getLatLng() : new u.LatLng(0, 0),
+      { icon: this, pane: t.options.clusterPane }
+    ), this._group = t, this._zoom = e, this._markers = [], this._childClusters = [], this._childCount = 0, this._iconNeedsUpdate = !0, this._boundsNeedUpdate = !0, this._bounds = new u.LatLngBounds(), i && this._addChild(i), n && this._addChild(n);
   },
   //Recursively retrieve all child markers of this cluster
-  getAllChildMarkers: function(storageArray) {
-    storageArray = storageArray || [];
-    for (let i = this._childClusters.length - 1; i >= 0; i--) {
-      this._childClusters[i].getAllChildMarkers(storageArray);
-    }
-    for (let j = this._markers.length - 1; j >= 0; j--) {
-      storageArray.push(this._markers[j]);
-    }
-    return storageArray;
+  getAllChildMarkers: function(t) {
+    t = t || [];
+    for (let e = this._childClusters.length - 1; e >= 0; e--)
+      this._childClusters[e].getAllChildMarkers(t);
+    for (let e = this._markers.length - 1; e >= 0; e--)
+      t.push(this._markers[e]);
+    return t;
   },
   //Returns the count of how many child markers we have
   getChildCount: function() {
     return this._childCount;
   },
   //Zoom to the minimum of showing all of the child markers, or the extents of this cluster
-  zoomToBounds: function(fitBoundsOptions) {
-    var childClusters = this._childClusters.slice(), map = this._group._map, boundsZoom = map.getBoundsZoom(this._bounds), zoom = this._zoom + 1, mapZoom = map.getZoom(), i;
-    while (childClusters.length > 0 && boundsZoom > zoom) {
-      zoom++;
-      let newClusters = [];
-      for (i = 0; i < childClusters.length; i++) {
-        newClusters = newClusters.concat(childClusters[i]._childClusters);
-      }
-      childClusters = newClusters;
-    }
-    if (boundsZoom > zoom) {
-      this._group._map.setView(this._latlng, zoom);
-    } else if (boundsZoom <= mapZoom) {
-      this._group._map.setView(this._latlng, mapZoom + 1);
-    } else {
-      this._group._map.fitBounds(this._bounds, fitBoundsOptions);
+  zoomToBounds: function(t) {
+    for (var e = this._childClusters.slice(), i = this._group._map, n = i.getBoundsZoom(this._bounds), s = this._zoom + 1, o = i.getZoom(), r; e.length > 0 && n > s; ) {
+      s++;
+      let a = [];
+      for (r = 0; r < e.length; r++)
+        a = a.concat(e[r]._childClusters);
+      e = a;
     }
+    n > s ? this._group._map.setView(this._latlng, s) : n <= o ? this._group._map.setView(this._latlng, o + 1) : this._group._map.fitBounds(this._bounds, t);
   },
   getBounds: function() {
-    var bounds = new L.LatLngBounds();
-    bounds.extend(this._bounds);
-    return bounds;
+    var t = new u.LatLngBounds();
+    return t.extend(this._bounds), t;
   },
   _updateIcon: function() {
-    this._iconNeedsUpdate = true;
-    if (this._icon) {
-      this.setIcon(this);
-    }
+    this._iconNeedsUpdate = !0, this._icon && this.setIcon(this);
   },
   //Cludge for Icon, we pretend to be an icon for performance
   createIcon: function() {
-    if (this._iconNeedsUpdate) {
-      this._iconObj = this._group.options.iconCreateFunction(this);
-      this._iconNeedsUpdate = false;
-    }
-    return this._iconObj.createIcon();
+    return this._iconNeedsUpdate && (this._iconObj = this._group.options.iconCreateFunction(this), this._iconNeedsUpdate = !1), this._iconObj.createIcon();
   },
   createShadow: function() {
     return this._iconObj.createShadow();
   },
-  _addChild: function(new1, isNotificationFromChild) {
-    this._iconNeedsUpdate = true;
-    this._boundsNeedUpdate = true;
-    this._setClusterCenter(new1);
-    if (new1 instanceof L.MarkerCluster) {
-      if (!isNotificationFromChild) {
-        this._childClusters.push(new1);
-        new1.__parent = this;
-      }
-      this._childCount += new1._childCount;
-    } else {
-      if (!isNotificationFromChild) {
-        this._markers.push(new1);
-      }
-      this._childCount++;
-    }
-    if (this.__parent) {
-      this.__parent._addChild(new1, true);
-    }
+  _addChild: function(t, e) {
+    this._iconNeedsUpdate = !0, this._boundsNeedUpdate = !0, this._setClusterCenter(t), t instanceof u.MarkerCluster ? (e || (this._childClusters.push(t), t.__parent = this), this._childCount += t._childCount) : (e || this._markers.push(t), this._childCount++), this.__parent && this.__parent._addChild(t, !0);
   },
   /**
    * Makes sure the cluster center is set. If not, uses the child center if it is a cluster, or the marker position.
    * @param child L.MarkerCluster|L.Marker that will be used as cluster center if not defined yet.
    * @private
    */
-  _setClusterCenter: function(child) {
-    if (!this._cLatLng) {
-      this._cLatLng = child._cLatLng || child._latlng;
-    }
+  _setClusterCenter: function(t) {
+    this._cLatLng || (this._cLatLng = t._cLatLng || t._latlng);
   },
   /**
    * Assigns impossible bounding values so that the next extend entirely determines the new bounds.
@@ -1193,192 +692,113 @@ L.MarkerCluster = L.Marker.extend({
    * @private
    */
   _resetBounds: function() {
-    var bounds = this._bounds;
-    if (bounds._southWest) {
-      bounds._southWest.lat = Infinity;
-      bounds._southWest.lng = Infinity;
-    }
-    if (bounds._northEast) {
-      bounds._northEast.lat = -Infinity;
-      bounds._northEast.lng = -Infinity;
-    }
+    var t = this._bounds;
+    t._southWest && (t._southWest.lat = 1 / 0, t._southWest.lng = 1 / 0), t._northEast && (t._northEast.lat = -1 / 0, t._northEast.lng = -1 / 0);
   },
   _recalculateBounds: function() {
-    var markers = this._markers, childClusters = this._childClusters, latSum = 0, lngSum = 0, totalCount = this._childCount, i, child, childLatLng, childCount;
-    if (totalCount === 0) {
-      return;
+    var t = this._markers, e = this._childClusters, i = 0, n = 0, s = this._childCount, o, r, a, h;
+    if (s !== 0) {
+      for (this._resetBounds(), o = 0; o < t.length; o++)
+        a = t[o]._latlng, this._bounds.extend(a), i += a.lat, n += a.lng;
+      for (o = 0; o < e.length; o++)
+        r = e[o], r._boundsNeedUpdate && r._recalculateBounds(), this._bounds.extend(r._bounds), a = r._wLatLng, h = r._childCount, i += a.lat * h, n += a.lng * h;
+      this._latlng = this._wLatLng = new u.LatLng(
+        i / s,
+        n / s
+      ), this._boundsNeedUpdate = !1;
     }
-    this._resetBounds();
-    for (i = 0; i < markers.length; i++) {
-      childLatLng = markers[i]._latlng;
-      this._bounds.extend(childLatLng);
-      latSum += childLatLng.lat;
-      lngSum += childLatLng.lng;
-    }
-    for (i = 0; i < childClusters.length; i++) {
-      child = childClusters[i];
-      if (child._boundsNeedUpdate) {
-        child._recalculateBounds();
-      }
-      this._bounds.extend(child._bounds);
-      childLatLng = child._wLatLng;
-      childCount = child._childCount;
-      latSum += childLatLng.lat * childCount;
-      lngSum += childLatLng.lng * childCount;
-    }
-    this._latlng = this._wLatLng = new L.LatLng(
-      latSum / totalCount,
-      lngSum / totalCount
-    );
-    this._boundsNeedUpdate = false;
   },
   //Set our markers position as given and add it to the map
-  _addToMap: function(startPos) {
-    if (startPos) {
-      this._backupLatlng = this._latlng;
-      this.setLatLng(startPos);
-    }
-    this._group._featureGroup.addLayer(this);
+  _addToMap: function(t) {
+    t && (this._backupLatlng = this._latlng, this.setLatLng(t)), this._group._featureGroup.addLayer(this);
   },
-  _recursivelyAnimateChildrenIn: function(bounds, center, maxZoom) {
+  _recursivelyAnimateChildrenIn: function(t, e, i) {
     this._recursively(
-      bounds,
+      t,
       this._group._map.getMinZoom(),
-      maxZoom - 1,
-      (c) => {
-        var markers = c._markers, i, m;
-        for (i = markers.length - 1; i >= 0; i--) {
-          m = markers[i];
-          if (m._icon) {
-            m._setPos(center);
-            m.clusterHide();
-          }
-        }
+      i - 1,
+      (n) => {
+        var s = n._markers, o, r;
+        for (o = s.length - 1; o >= 0; o--)
+          r = s[o], r._icon && (r._setPos(e), r.clusterHide());
       },
-      (c) => {
-        var childClusters = c._childClusters, j, cm;
-        for (j = childClusters.length - 1; j >= 0; j--) {
-          cm = childClusters[j];
-          if (cm._icon) {
-            cm._setPos(center);
-            cm.clusterHide();
-          }
-        }
+      (n) => {
+        var s = n._childClusters, o, r;
+        for (o = s.length - 1; o >= 0; o--)
+          r = s[o], r._icon && (r._setPos(e), r.clusterHide());
       }
     );
   },
-  _recursivelyAnimateChildrenInAndAddSelfToMap: function(bounds, mapMinZoom, previousZoomLevel, newZoomLevel) {
-    this._recursively(bounds, newZoomLevel, mapMinZoom, (c) => {
-      c._recursivelyAnimateChildrenIn(
-        bounds,
-        c._group._map.latLngToLayerPoint(c.getLatLng()).round(),
-        previousZoomLevel
-      );
-      if (c._isSingleParent() && previousZoomLevel - 1 === newZoomLevel) {
-        c.clusterShow();
-        c._recursivelyRemoveChildrenFromMap(
-          bounds,
-          mapMinZoom,
-          previousZoomLevel
-        );
-      } else {
-        c.clusterHide();
-      }
-      c._addToMap();
+  _recursivelyAnimateChildrenInAndAddSelfToMap: function(t, e, i, n) {
+    this._recursively(t, n, e, (s) => {
+      s._recursivelyAnimateChildrenIn(
+        t,
+        s._group._map.latLngToLayerPoint(s.getLatLng()).round(),
+        i
+      ), s._isSingleParent() && i - 1 === n ? (s.clusterShow(), s._recursivelyRemoveChildrenFromMap(
+        t,
+        e,
+        i
+      )) : s.clusterHide(), s._addToMap();
     });
   },
-  _recursivelyBecomeVisible: function(bounds, zoomLevel) {
+  _recursivelyBecomeVisible: function(t, e) {
     this._recursively(
-      bounds,
+      t,
       this._group._map.getMinZoom(),
-      zoomLevel,
+      e,
       null,
-      (c) => {
-        c.clusterShow();
+      (i) => {
+        i.clusterShow();
       }
     );
   },
-  _recursivelyAddChildrenToMap: function(startPos, zoomLevel, bounds) {
+  _recursivelyAddChildrenToMap: function(t, e, i) {
     this._recursively(
-      bounds,
+      i,
       this._group._map.getMinZoom() - 1,
-      zoomLevel,
-      (c) => {
-        if (zoomLevel === c._zoom) {
-          return;
-        }
-        for (let i = c._markers.length - 1; i >= 0; i--) {
-          const nm = c._markers[i];
-          if (!bounds.contains(nm._latlng)) {
-            continue;
-          }
-          if (startPos) {
-            nm._backupLatlng = nm.getLatLng();
-            nm.setLatLng(startPos);
-            if (nm.clusterHide) {
-              nm.clusterHide();
-            }
+      e,
+      (n) => {
+        if (e !== n._zoom)
+          for (let s = n._markers.length - 1; s >= 0; s--) {
+            const o = n._markers[s];
+            i.contains(o._latlng) && (t && (o._backupLatlng = o.getLatLng(), o.setLatLng(t), o.clusterHide && o.clusterHide()), n._group._featureGroup.addLayer(o));
           }
-          c._group._featureGroup.addLayer(nm);
-        }
       },
-      (c) => {
-        c._addToMap(startPos);
+      (n) => {
+        n._addToMap(t);
       }
     );
   },
-  _recursivelyRestoreChildPositions: function(zoomLevel) {
-    for (let i = this._markers.length - 1; i >= 0; i--) {
-      const nm = this._markers[i];
-      if (nm._backupLatlng) {
-        nm.setLatLng(nm._backupLatlng);
-        delete nm._backupLatlng;
-      }
-    }
-    if (zoomLevel - 1 === this._zoom) {
-      for (let j = this._childClusters.length - 1; j >= 0; j--) {
-        this._childClusters[j]._restorePosition();
-      }
-    } else {
-      for (let k = this._childClusters.length - 1; k >= 0; k--) {
-        this._childClusters[k]._recursivelyRestoreChildPositions(zoomLevel);
-      }
+  _recursivelyRestoreChildPositions: function(t) {
+    for (let e = this._markers.length - 1; e >= 0; e--) {
+      const i = this._markers[e];
+      i._backupLatlng && (i.setLatLng(i._backupLatlng), delete i._backupLatlng);
     }
+    if (t - 1 === this._zoom)
+      for (let e = this._childClusters.length - 1; e >= 0; e--)
+        this._childClusters[e]._restorePosition();
+    else
+      for (let e = this._childClusters.length - 1; e >= 0; e--)
+        this._childClusters[e]._recursivelyRestoreChildPositions(t);
   },
   _restorePosition: function() {
-    if (this._backupLatlng) {
-      this.setLatLng(this._backupLatlng);
-      delete this._backupLatlng;
-    }
+    this._backupLatlng && (this.setLatLng(this._backupLatlng), delete this._backupLatlng);
   },
   //exceptBounds: If set, don't remove any markers/clusters in it
-  _recursivelyRemoveChildrenFromMap: function(previousBounds, mapMinZoom, zoomLevel, exceptBounds) {
-    var m, i;
+  _recursivelyRemoveChildrenFromMap: function(t, e, i, n) {
+    var s, o;
     this._recursively(
-      previousBounds,
-      mapMinZoom - 1,
-      zoomLevel - 1,
-      (c) => {
-        for (i = c._markers.length - 1; i >= 0; i--) {
-          m = c._markers[i];
-          if (!exceptBounds || !exceptBounds.contains(m._latlng)) {
-            c._group._featureGroup.removeLayer(m);
-            if (m.clusterShow) {
-              m.clusterShow();
-            }
-          }
-        }
+      t,
+      e - 1,
+      i - 1,
+      (r) => {
+        for (o = r._markers.length - 1; o >= 0; o--)
+          s = r._markers[o], (!n || !n.contains(s._latlng)) && (r._group._featureGroup.removeLayer(s), s.clusterShow && s.clusterShow());
       },
-      (c) => {
-        for (i = c._childClusters.length - 1; i >= 0; i--) {
-          m = c._childClusters[i];
-          if (!exceptBounds || !exceptBounds.contains(m._latlng)) {
-            c._group._featureGroup.removeLayer(m);
-            if (m.clusterShow) {
-              m.clusterShow();
-            }
-          }
-        }
+      (r) => {
+        for (o = r._childClusters.length - 1; o >= 0; o--)
+          s = r._childClusters[o], (!n || !n.contains(s._latlng)) && (r._group._featureGroup.removeLayer(s), s.clusterShow && s.clusterShow());
       }
     );
   },
@@ -1388,250 +808,162 @@ L.MarkerCluster = L.Marker.extend({
   // zoomLevelToStop: zoom level to stop running functions (inclusive)
   // runAtEveryLevel: function that takes an L.MarkerCluster as an argument that should be applied on every level
   // runAtBottomLevel: function that takes an L.MarkerCluster as an argument that should be applied at only the bottom level
-  _recursively: function(boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel) {
-    var childClusters = this._childClusters, zoom = this._zoom, i, c;
-    if (zoomLevelToStart <= zoom) {
-      if (runAtEveryLevel) {
-        runAtEveryLevel(this);
-      }
-      if (runAtBottomLevel && zoom === zoomLevelToStop) {
-        runAtBottomLevel(this);
-      }
-    }
-    if (zoom < zoomLevelToStart || zoom < zoomLevelToStop) {
-      for (i = childClusters.length - 1; i >= 0; i--) {
-        c = childClusters[i];
-        if (boundsToApplyTo.intersects(c._bounds)) {
-          c._recursively(
-            boundsToApplyTo,
-            zoomLevelToStart,
-            zoomLevelToStop,
-            runAtEveryLevel,
-            runAtBottomLevel
-          );
-        }
-      }
-    }
+  _recursively: function(t, e, i, n, s) {
+    var o = this._childClusters, r = this._zoom, a, h;
+    if (e <= r && (n && n(this), s && r === i && s(this)), r < e || r < i)
+      for (a = o.length - 1; a >= 0; a--)
+        h = o[a], t.intersects(h._bounds) && h._recursively(
+          t,
+          e,
+          i,
+          n,
+          s
+        );
   },
   //Returns true if we are the parent of only one cluster and that cluster is the same as us
   _isSingleParent: function() {
     return this._childClusters.length > 0 && this._childClusters[0]._childCount === this._childCount;
   }
 });
-L.Marker.include({
+u.Marker.include({
   clusterHide: function() {
-    this.options.opacityWhenUnclustered = this.options.opacity || 1;
-    return this.setOpacity(0);
+    return this.options.opacityWhenUnclustered = this.options.opacity || 1, this.setOpacity(0);
   },
   clusterShow: function() {
-    var ret = this.setOpacity(
+    var t = this.setOpacity(
       this.options.opacity || this.options.opacityWhenUnclustered
     );
-    delete this.options.opacityWhenUnclustered;
-    return ret;
+    return delete this.options.opacityWhenUnclustered, t;
   }
 });
-L.DistanceGrid = function(cellSize) {
-  this._cellSize = cellSize;
-  this._sqCellSize = cellSize * cellSize;
-  this._grid = {};
-  this._objectPoint = {};
+u.DistanceGrid = function(t) {
+  this._cellSize = t, this._sqCellSize = t * t, this._grid = {}, this._objectPoint = {};
 };
-L.DistanceGrid.prototype = {
-  addObject: function(obj, point) {
-    var x = this._getCoord(point.x);
-    var y = this._getCoord(point.y);
-    var grid = this._grid;
-    grid[y] = grid[y] || {};
-    var row = grid[y];
-    row[x] = row[x] || [];
-    var cell = row[x];
-    var stamp = L.Util.stamp(obj);
-    this._objectPoint[stamp] = point;
-    cell.push(obj);
-  },
-  updateObject: function(obj, point) {
-    this.removeObject(obj);
-    this.addObject(obj, point);
+u.DistanceGrid.prototype = {
+  addObject: function(t, e) {
+    var i = this._getCoord(e.x), n = this._getCoord(e.y), s = this._grid;
+    s[n] = s[n] || {};
+    var o = s[n];
+    o[i] = o[i] || [];
+    var r = o[i], a = u.Util.stamp(t);
+    this._objectPoint[a] = e, r.push(t);
+  },
+  updateObject: function(t, e) {
+    this.removeObject(t), this.addObject(t, e);
   },
   //Returns true if the object was found
-  removeObject: function(obj, point) {
-    var x = this._getCoord(point.x);
-    var y = this._getCoord(point.y);
-    var grid = this._grid;
-    grid[y] = grid[y] || {};
-    var row = grid[y];
-    row[x] = row[x] || [];
-    var cell = row[x];
-    var i, len;
-    delete this._objectPoint[L.Util.stamp(obj)];
-    for (i = 0, len = cell.length; i < len; i++) {
-      if (cell[i] === obj) {
-        cell.splice(i, 1);
-        if (len === 1) {
-          delete row[x];
-        }
-        return true;
-      }
-    }
-  },
-  eachObject: function(fn, context) {
-    var i, j, k, len, row, cell, removed, grid = this._grid;
-    for (i in grid) {
-      row = grid[i];
-      for (j in row) {
-        cell = row[j];
-        for (k = 0, len = cell.length; k < len; k++) {
-          removed = fn.call(context, cell[k]);
-          if (removed) {
-            k--;
-            len--;
-          }
-        }
-      }
-    }
-  },
-  getNearObject: function(point) {
-    var x = this._getCoord(point.x), y = this._getCoord(point.y), i, j, k, row, cell, len, obj, dist, objectPoint = this._objectPoint, closestDistSq = this._sqCellSize, closest = null;
-    for (i = y - 1; i <= y + 1; i++) {
-      row = this._grid[i];
-      if (row) {
-        for (j = x - 1; j <= x + 1; j++) {
-          cell = row[j];
-          if (cell) {
-            for (k = 0, len = cell.length; k < len; k++) {
-              obj = cell[k];
-              dist = this._sqDist(objectPoint[L.Util.stamp(obj)], point);
-              if (dist < closestDistSq) {
-                closestDistSq = dist;
-                closest = obj;
-              }
-            }
-          }
-        }
-      }
+  removeObject: function(t, e) {
+    var i = this._getCoord(e.x), n = this._getCoord(e.y), s = this._grid;
+    s[n] = s[n] || {};
+    var o = s[n];
+    o[i] = o[i] || [];
+    var r = o[i], a, h;
+    for (delete this._objectPoint[u.Util.stamp(t)], a = 0, h = r.length; a < h; a++)
+      if (r[a] === t)
+        return r.splice(a, 1), h === 1 && delete o[i], !0;
+  },
+  eachObject: function(t, e) {
+    var i, n, s, o, r, a, h, _ = this._grid;
+    for (i in _) {
+      r = _[i];
+      for (n in r)
+        for (a = r[n], s = 0, o = a.length; s < o; s++)
+          h = t.call(e, a[s]), h && (s--, o--);
+    }
+  },
+  getNearObject: function(t) {
+    var e = this._getCoord(t.x), i = this._getCoord(t.y), n, s, o, r, a, h, _, l, d = this._objectPoint, p = this._sqCellSize, f = null;
+    for (n = i - 1; n <= i + 1; n++)
+      if (r = this._grid[n], r) {
+        for (s = e - 1; s <= e + 1; s++)
+          if (a = r[s], a)
+            for (o = 0, h = a.length; o < h; o++)
+              _ = a[o], l = this._sqDist(d[u.Util.stamp(_)], t), l < p && (p = l, f = _);
+      }
+    return f;
+  },
+  _getCoord: function(t) {
+    return Math.floor(t / this._cellSize);
+  },
+  _sqDist: (t, e) => {
+    var i = e.x - t.x, n = e.y - t.y;
+    return i * i + n * n;
+  }
+};
+u.QuickHull = {
+  /*
+   * @param {Object} cpt a point to be measured from the baseline
+   * @param {Array} bl the baseline, as represented by a two-element
+   *   array of latlng objects.
+   * @returns {Number} an approximate distance measure
+   */
+  getDistant: (t, e) => {
+    var i = e[1].lat - e[0].lat, n = e[0].lng - e[1].lng;
+    return n * (t.lat - e[0].lat) + i * (t.lng - e[0].lng);
+  },
+  /*
+   * @param {Array} baseLine a two-element array of latlng objects
+   *   representing the baseline to project from
+   * @param {Array} latLngs an array of latlng objects
+   * @returns {Object} the maximum point and all new points to stay
+   *   in consideration for the hull.
+   */
+  findMostDistantPointFromBaseLine: function(t, e) {
+    var i = 0, n = null, s = [], o, r, a;
+    for (o = e.length - 1; o >= 0; o--) {
+      if (r = e[o], a = this.getDistant(r, t), a > 0)
+        s.push(r);
+      else
+        continue;
+      a > i && (i = a, n = r);
     }
-    return closest;
-  },
-  _getCoord: function(x) {
-    return Math.floor(x / this._cellSize);
+    return { maxPoint: n, newPoints: s };
   },
-  _sqDist: (p, p2) => {
-    var dx = p2.x - p.x, dy = p2.y - p.y;
-    return dx * dx + dy * dy;
+  /*
+   * Given a baseline, compute the convex hull of latLngs as an array
+   * of latLngs.
+   *
+   * @param {Array} latLngs
+   * @returns {Array}
+   */
+  buildConvexHull: function(t, e) {
+    var i = [], n = this.findMostDistantPointFromBaseLine(t, e);
+    return n.maxPoint ? (i = i.concat(
+      this.buildConvexHull([t[0], n.maxPoint], n.newPoints)
+    ), i = i.concat(
+      this.buildConvexHull([n.maxPoint, t[1]], n.newPoints)
+    ), i) : [t[0]];
+  },
+  /*
+   * Given an array of latlngs, compute a convex hull as an array
+   * of latlngs
+   *
+   * @param {Array} latLngs
+   * @returns {Array}
+   */
+  getConvexHull: function(t) {
+    var e = !1, i = !1, n = !1, s = !1, o = null, r = null, a = null, h = null, _ = null, l = null, d;
+    for (d = t.length - 1; d >= 0; d--) {
+      const f = t[d];
+      (e === !1 || f.lat > e) && (o = f, e = f.lat), (i === !1 || f.lat < i) && (r = f, i = f.lat), (n === !1 || f.lng > n) && (a = f, n = f.lng), (s === !1 || f.lng < s) && (h = f, s = f.lng);
+    }
+    i !== e ? (l = r, _ = o) : (l = h, _ = a);
+    var p = [].concat(
+      this.buildConvexHull([l, _], t),
+      this.buildConvexHull([_, l], t)
+    );
+    return p;
   }
 };
-(() => {
-  L.QuickHull = {
-    /*
-     * @param {Object} cpt a point to be measured from the baseline
-     * @param {Array} bl the baseline, as represented by a two-element
-     *   array of latlng objects.
-     * @returns {Number} an approximate distance measure
-     */
-    getDistant: (cpt, bl) => {
-      var vY = bl[1].lat - bl[0].lat, vX = bl[0].lng - bl[1].lng;
-      return vX * (cpt.lat - bl[0].lat) + vY * (cpt.lng - bl[0].lng);
-    },
-    /*
-     * @param {Array} baseLine a two-element array of latlng objects
-     *   representing the baseline to project from
-     * @param {Array} latLngs an array of latlng objects
-     * @returns {Object} the maximum point and all new points to stay
-     *   in consideration for the hull.
-     */
-    findMostDistantPointFromBaseLine: function(baseLine, latLngs) {
-      var maxD = 0, maxPt = null, newPoints = [], i, pt, d;
-      for (i = latLngs.length - 1; i >= 0; i--) {
-        pt = latLngs[i];
-        d = this.getDistant(pt, baseLine);
-        if (d > 0) {
-          newPoints.push(pt);
-        } else {
-          continue;
-        }
-        if (d > maxD) {
-          maxD = d;
-          maxPt = pt;
-        }
-      }
-      return { maxPoint: maxPt, newPoints };
-    },
-    /*
-     * Given a baseline, compute the convex hull of latLngs as an array
-     * of latLngs.
-     *
-     * @param {Array} latLngs
-     * @returns {Array}
-     */
-    buildConvexHull: function(baseLine, latLngs) {
-      var convexHullBaseLines = [], t = this.findMostDistantPointFromBaseLine(baseLine, latLngs);
-      if (t.maxPoint) {
-        convexHullBaseLines = convexHullBaseLines.concat(
-          this.buildConvexHull([baseLine[0], t.maxPoint], t.newPoints)
-        );
-        convexHullBaseLines = convexHullBaseLines.concat(
-          this.buildConvexHull([t.maxPoint, baseLine[1]], t.newPoints)
-        );
-        return convexHullBaseLines;
-      } else {
-        return [baseLine[0]];
-      }
-    },
-    /*
-     * Given an array of latlngs, compute a convex hull as an array
-     * of latlngs
-     *
-     * @param {Array} latLngs
-     * @returns {Array}
-     */
-    getConvexHull: function(latLngs) {
-      var maxLat = false, minLat = false, maxLng = false, minLng = false, maxLatPt = null, minLatPt = null, maxLngPt = null, minLngPt = null, maxPt = null, minPt = null, i;
-      for (i = latLngs.length - 1; i >= 0; i--) {
-        const pt = latLngs[i];
-        if (maxLat === false || pt.lat > maxLat) {
-          maxLatPt = pt;
-          maxLat = pt.lat;
-        }
-        if (minLat === false || pt.lat < minLat) {
-          minLatPt = pt;
-          minLat = pt.lat;
-        }
-        if (maxLng === false || pt.lng > maxLng) {
-          maxLngPt = pt;
-          maxLng = pt.lng;
-        }
-        if (minLng === false || pt.lng < minLng) {
-          minLngPt = pt;
-          minLng = pt.lng;
-        }
-      }
-      if (minLat !== maxLat) {
-        minPt = minLatPt;
-        maxPt = maxLatPt;
-      } else {
-        minPt = minLngPt;
-        maxPt = maxLngPt;
-      }
-      var ch = [].concat(
-        this.buildConvexHull([minPt, maxPt], latLngs),
-        this.buildConvexHull([maxPt, minPt], latLngs)
-      );
-      return ch;
-    }
-  };
-})();
-L.MarkerCluster.include({
+u.MarkerCluster.include({
   getConvexHull: function() {
-    var childMarkers = this.getAllChildMarkers(), points = [], p, i;
-    for (i = childMarkers.length - 1; i >= 0; i--) {
-      p = childMarkers[i].getLatLng();
-      points.push(p);
-    }
-    return L.QuickHull.getConvexHull(points);
+    var t = this.getAllChildMarkers(), e = [], i, n;
+    for (n = t.length - 1; n >= 0; n--)
+      i = t[n].getLatLng(), e.push(i);
+    return u.QuickHull.getConvexHull(e);
   }
 });
-L.MarkerCluster.include({
+u.MarkerCluster.include({
   _2PI: Math.PI * 2,
   _circleFootSeparation: 25,
   //related to circumference of circle
@@ -1644,311 +976,129 @@ L.MarkerCluster.include({
   //show spiral instead of circle from this marker count upwards.
   // 0 -> always spiral; Infinity -> always circle
   spiderfy: function() {
-    if (this._group._spiderfied === this || this._group._inZoomAnimation) {
-      return;
-    }
-    var childMarkers = this.getAllChildMarkers(), group = this._group, map = group._map, center = map.latLngToLayerPoint(this._latlng), positions;
-    this._group._unspiderfy();
-    this._group._spiderfied = this;
-    if (childMarkers.length >= this._circleSpiralSwitchover) {
-      positions = this._generatePointsSpiral(childMarkers.length, center);
-    } else {
-      center.y += 10;
-      positions = this._generatePointsCircle(childMarkers.length, center);
+    if (!(this._group._spiderfied === this || this._group._inZoomAnimation)) {
+      var t = this.getAllChildMarkers(), e = this._group, i = e._map, n = i.latLngToLayerPoint(this._latlng), s;
+      this._group._unspiderfy(), this._group._spiderfied = this, t.length >= this._circleSpiralSwitchover ? s = this._generatePointsSpiral(t.length, n) : (n.y += 10, s = this._generatePointsCircle(t.length, n)), this._animationSpiderfy(t, s);
     }
-    this._animationSpiderfy(childMarkers, positions);
   },
-  unspiderfy: function(zoomDetails) {
-    if (this._group._inZoomAnimation) {
-      return;
-    }
-    this._animationUnspiderfy(zoomDetails);
-    this._group._spiderfied = null;
-  },
-  _generatePointsCircle: function(count, centerPt) {
-    var circumference = this._group.options.spiderfyDistanceMultiplier * this._circleFootSeparation * (2 + count), legLength = circumference / this._2PI, angleStep = this._2PI / count, res = [], i, angle;
-    res.length = count;
-    for (i = count - 1; i >= 0; i--) {
-      angle = this._circleStartAngle + i * angleStep;
-      res[i] = new L.Point(
-        centerPt.x + legLength * Math.cos(angle),
-        centerPt.y + legLength * Math.sin(angle)
-      )._round();
-    }
-    return res;
-  },
-  _generatePointsSpiral: function(count, centerPt) {
-    var spiderfyDistanceMultiplier = this._group.options.spiderfyDistanceMultiplier, legLength = spiderfyDistanceMultiplier * this._spiralLengthStart, separation = spiderfyDistanceMultiplier * this._spiralFootSeparation, lengthFactor = spiderfyDistanceMultiplier * this._spiralLengthFactor * this._2PI, angle = 0, res = [], i;
-    res.length = count;
-    for (i = count - 1; i >= 0; i--) {
-      angle += separation / legLength + i * 5e-4;
-      res[i] = new L.Point(
-        centerPt.x + legLength * Math.cos(angle),
-        centerPt.y + legLength * Math.sin(angle)
+  unspiderfy: function(t) {
+    this._group._inZoomAnimation || (this._animationUnspiderfy(t), this._group._spiderfied = null);
+  },
+  _generatePointsCircle: function(t, e) {
+    var i = this._group.options.spiderfyDistanceMultiplier * this._circleFootSeparation * (2 + t), n = i / this._2PI, s = this._2PI / t, o = [], r, a;
+    for (o.length = t, r = t - 1; r >= 0; r--)
+      a = this._circleStartAngle + r * s, o[r] = new u.Point(
+        e.x + n * Math.cos(a),
+        e.y + n * Math.sin(a)
       )._round();
-      legLength += lengthFactor / angle;
-    }
-    return res;
+    return o;
+  },
+  _generatePointsSpiral: function(t, e) {
+    var i = this._group.options.spiderfyDistanceMultiplier, n = i * this._spiralLengthStart, s = i * this._spiralFootSeparation, o = i * this._spiralLengthFactor * this._2PI, r = 0, a = [], h;
+    for (a.length = t, h = t - 1; h >= 0; h--)
+      r += s / n + h * 5e-4, a[h] = new u.Point(
+        e.x + n * Math.cos(r),
+        e.y + n * Math.sin(r)
+      )._round(), n += o / r;
+    return a;
   },
   _noanimationUnspiderfy: function() {
-    var group = this._group, map = group._map, fg = group._featureGroup, childMarkers = this.getAllChildMarkers(), m, i;
-    group._ignoreMove = true;
-    this.setOpacity(1);
-    for (i = childMarkers.length - 1; i >= 0; i--) {
-      m = childMarkers[i];
-      fg.removeLayer(m);
-      if (m._preSpiderfyLatlng) {
-        m.setLatLng(m._preSpiderfyLatlng);
-        delete m._preSpiderfyLatlng;
-      }
-      if (m.setZIndexOffset) {
-        m.setZIndexOffset(0);
-      }
-      if (m._spiderLeg) {
-        map.removeLayer(m._spiderLeg);
-        delete m._spiderLeg;
-      }
-    }
-    group.fire("unspiderfied", {
+    var t = this._group, e = t._map, i = t._featureGroup, n = this.getAllChildMarkers(), s, o;
+    for (t._ignoreMove = !0, this.setOpacity(1), o = n.length - 1; o >= 0; o--)
+      s = n[o], i.removeLayer(s), s._preSpiderfyLatlng && (s.setLatLng(s._preSpiderfyLatlng), delete s._preSpiderfyLatlng), s.setZIndexOffset && s.setZIndexOffset(0), s._spiderLeg && (e.removeLayer(s._spiderLeg), delete s._spiderLeg);
+    t.fire("unspiderfied", {
       cluster: this,
-      markers: childMarkers
-    });
-    group._ignoreMove = false;
-    group._spiderfied = null;
+      markers: n
+    }), t._ignoreMove = !1, t._spiderfied = null;
   }
 });
-L.MarkerClusterNonAnimated = L.MarkerCluster.extend({
-  _animationSpiderfy: function(childMarkers, positions) {
-    var group = this._group, map = group._map, fg = group._featureGroup, legOptions = this._group.options.spiderLegPolylineOptions, i, m, leg, newPos;
-    group._ignoreMove = true;
-    for (i = 0; i < childMarkers.length; i++) {
-      newPos = map.layerPointToLatLng(positions[i]);
-      m = childMarkers[i];
-      leg = new L.Polyline([this._latlng, newPos], legOptions);
-      map.addLayer(leg);
-      m._spiderLeg = leg;
-      m._preSpiderfyLatlng = m._latlng;
-      m.setLatLng(newPos);
-      if (m.setZIndexOffset) {
-        m.setZIndexOffset(1e6);
-      }
-      fg.addLayer(m);
-    }
-    this.setOpacity(0.3);
-    group._ignoreMove = false;
-    group.fire("spiderfied", {
+u.MarkerClusterNonAnimated = u.MarkerCluster.extend({
+  _animationSpiderfy: function(t, e) {
+    var i = this._group, n = i._map, s = i._featureGroup, o = this._group.options.spiderLegPolylineOptions, r, a, h, _;
+    for (i._ignoreMove = !0, r = 0; r < t.length; r++)
+      _ = n.layerPointToLatLng(e[r]), a = t[r], h = new u.Polyline([this._latlng, _], o), n.addLayer(h), a._spiderLeg = h, a._preSpiderfyLatlng = a._latlng, a.setLatLng(_), a.setZIndexOffset && a.setZIndexOffset(1e6), s.addLayer(a);
+    this.setOpacity(0.3), i._ignoreMove = !1, i.fire("spiderfied", {
       cluster: this,
-      markers: childMarkers
+      markers: t
     });
   },
   _animationUnspiderfy: function() {
     this._noanimationUnspiderfy();
   }
 });
-L.MarkerCluster.include({
-  _animationSpiderfy: function(childMarkers, positions) {
-    var group = this._group, map = group._map, fg = group._featureGroup, thisLayerLatLng = this._latlng, thisLayerPos = map.latLngToLayerPoint(thisLayerLatLng), svg = L.Path.SVG, legOptions = Object.assign(
+u.MarkerCluster.include({
+  _animationSpiderfy: function(t, e) {
+    var i = this._group, n = i._map, s = i._featureGroup, o = this._latlng, r = n.latLngToLayerPoint(o), a = u.Path.SVG, h = Object.assign(
       {},
       this._group.options.spiderLegPolylineOptions
-    ), finalLegOpacity = legOptions.opacity, i, m, leg, legPath, legLength, newPos;
-    if (finalLegOpacity === void 0) {
-      finalLegOpacity = L.MarkerClusterGroup.prototype.options.spiderLegPolylineOptions.opacity;
-    }
-    if (svg) {
-      legOptions.opacity = 0;
-      legOptions.className = `${legOptions.className || ""} leaflet-cluster-spider-leg`;
-    } else {
-      legOptions.opacity = finalLegOpacity;
-    }
-    group._ignoreMove = true;
-    for (i = 0; i < childMarkers.length; i++) {
-      m = childMarkers[i];
-      newPos = map.layerPointToLatLng(positions[i]);
-      leg = new L.Polyline([thisLayerLatLng, newPos], legOptions);
-      map.addLayer(leg);
-      m._spiderLeg = leg;
-      if (svg) {
-        legPath = leg._path;
-        legLength = legPath.getTotalLength() + 0.1;
-        legPath.style.strokeDasharray = legLength;
-        legPath.style.strokeDashoffset = legLength;
-      }
-      if (m.setZIndexOffset) {
-        m.setZIndexOffset(1e6);
-      }
-      if (m.clusterHide) {
-        m.clusterHide();
-      }
-      fg.addLayer(m);
-      if (m._setPos) {
-        m._setPos(thisLayerPos);
-      }
-    }
-    group._forceLayout();
-    group._animationStart();
-    for (i = childMarkers.length - 1; i >= 0; i--) {
-      newPos = map.layerPointToLatLng(positions[i]);
-      m = childMarkers[i];
-      m._preSpiderfyLatlng = m._latlng;
-      m.setLatLng(newPos);
-      if (m.clusterShow) {
-        m.clusterShow();
-      }
-      if (svg) {
-        leg = m._spiderLeg;
-        legPath = leg._path;
-        legPath.style.strokeDashoffset = 0;
-        leg.setStyle({ opacity: finalLegOpacity });
-      }
-    }
-    this.setOpacity(0.3);
-    group._ignoreMove = false;
-    setTimeout(() => {
-      group._animationEnd();
-      group.fire("spiderfied", {
+    ), _ = h.opacity, l, d, p, f, c, g;
+    for (_ === void 0 && (_ = u.MarkerClusterGroup.prototype.options.spiderLegPolylineOptions.opacity), a ? (h.opacity = 0, h.className = `${h.className || ""} leaflet-cluster-spider-leg`) : h.opacity = _, i._ignoreMove = !0, l = 0; l < t.length; l++)
+      d = t[l], g = n.layerPointToLatLng(e[l]), p = new u.Polyline([o, g], h), n.addLayer(p), d._spiderLeg = p, a && (f = p._path, c = f.getTotalLength() + 0.1, f.style.strokeDasharray = c, f.style.strokeDashoffset = c), d.setZIndexOffset && d.setZIndexOffset(1e6), d.clusterHide && d.clusterHide(), s.addLayer(d), d._setPos && d._setPos(r);
+    for (i._forceLayout(), i._animationStart(), l = t.length - 1; l >= 0; l--)
+      g = n.layerPointToLatLng(e[l]), d = t[l], d._preSpiderfyLatlng = d._latlng, d.setLatLng(g), d.clusterShow && d.clusterShow(), a && (p = d._spiderLeg, f = p._path, f.style.strokeDashoffset = 0, p.setStyle({ opacity: _ }));
+    this.setOpacity(0.3), i._ignoreMove = !1, setTimeout(() => {
+      i._animationEnd(), i.fire("spiderfied", {
         cluster: this,
-        markers: childMarkers
+        markers: t
       });
     }, 200);
   },
-  _animationUnspiderfy: function(zoomDetails) {
-    var group = this._group, map = group._map, fg = group._featureGroup, thisLayerPos = zoomDetails ? map._latLngToNewLayerPoint(
+  _animationUnspiderfy: function(t) {
+    var e = this._group, i = e._map, n = e._featureGroup, s = t ? i._latLngToNewLayerPoint(
       this._latlng,
-      zoomDetails.zoom,
-      zoomDetails.center
-    ) : map.latLngToLayerPoint(this._latlng), childMarkers = this.getAllChildMarkers(), svg = L.Path.SVG, m, i, leg, legPath, legLength, nonAnimatable;
-    group._ignoreMove = true;
-    group._animationStart();
-    this.setOpacity(1);
-    for (i = childMarkers.length - 1; i >= 0; i--) {
-      m = childMarkers[i];
-      if (!m._preSpiderfyLatlng) {
-        continue;
-      }
-      m.closePopup();
-      m.setLatLng(m._preSpiderfyLatlng);
-      delete m._preSpiderfyLatlng;
-      nonAnimatable = true;
-      if (m._setPos) {
-        m._setPos(thisLayerPos);
-        nonAnimatable = false;
-      }
-      if (m.clusterHide) {
-        m.clusterHide();
-        nonAnimatable = false;
-      }
-      if (nonAnimatable) {
-        fg.removeLayer(m);
-      }
-      if (svg) {
-        leg = m._spiderLeg;
-        legPath = leg._path;
-        legLength = legPath.getTotalLength() + 0.1;
-        legPath.style.strokeDashoffset = legLength;
-        leg.setStyle({ opacity: 0 });
-      }
-    }
-    group._ignoreMove = false;
-    setTimeout(() => {
-      var stillThereChildCount = 0;
-      for (i = childMarkers.length - 1; i >= 0; i--) {
-        m = childMarkers[i];
-        if (m._spiderLeg) {
-          stillThereChildCount++;
-        }
-      }
-      for (i = childMarkers.length - 1; i >= 0; i--) {
-        m = childMarkers[i];
-        if (!m._spiderLeg) {
-          continue;
-        }
-        if (m.clusterShow) {
-          m.clusterShow();
-        }
-        if (m.setZIndexOffset) {
-          m.setZIndexOffset(0);
-        }
-        if (stillThereChildCount > 1) {
-          fg.removeLayer(m);
-        }
-        map.removeLayer(m._spiderLeg);
-        delete m._spiderLeg;
-      }
-      group._animationEnd();
-      group.fire("unspiderfied", {
+      t.zoom,
+      t.center
+    ) : i.latLngToLayerPoint(this._latlng), o = this.getAllChildMarkers(), r = u.Path.SVG, a, h, _, l, d, p;
+    for (e._ignoreMove = !0, e._animationStart(), this.setOpacity(1), h = o.length - 1; h >= 0; h--)
+      a = o[h], a._preSpiderfyLatlng && (a.closePopup(), a.setLatLng(a._preSpiderfyLatlng), delete a._preSpiderfyLatlng, p = !0, a._setPos && (a._setPos(s), p = !1), a.clusterHide && (a.clusterHide(), p = !1), p && n.removeLayer(a), r && (_ = a._spiderLeg, l = _._path, d = l.getTotalLength() + 0.1, l.style.strokeDashoffset = d, _.setStyle({ opacity: 0 })));
+    e._ignoreMove = !1, setTimeout(() => {
+      var f = 0;
+      for (h = o.length - 1; h >= 0; h--)
+        a = o[h], a._spiderLeg && f++;
+      for (h = o.length - 1; h >= 0; h--)
+        a = o[h], a._spiderLeg && (a.clusterShow && a.clusterShow(), a.setZIndexOffset && a.setZIndexOffset(0), f > 1 && n.removeLayer(a), i.removeLayer(a._spiderLeg), delete a._spiderLeg);
+      e._animationEnd(), e.fire("unspiderfied", {
         cluster: this,
-        markers: childMarkers
+        markers: o
       });
     }, 200);
   }
 });
-L.MarkerClusterGroup.include({
+u.MarkerClusterGroup.include({
   //The MarkerCluster currently spiderfied (if any)
   _spiderfied: null,
-  unspiderfy: function(...args) {
-    this._unspiderfy.apply(this, args);
+  unspiderfy: function(...t) {
+    this._unspiderfy.apply(this, t);
   },
   _spiderfierOnAdd: function() {
-    this._map.on("click", this._unspiderfyWrapper, this);
-    if (this._map.options.zoomAnimation) {
-      this._map.on("zoomstart", this._unspiderfyZoomStart, this);
-    }
-    this._map.on("zoomend", this._noanimationUnspiderfy, this);
-    if (!L.Browser.touch) {
-      this._map.getRenderer(this);
-    }
+    this._map.on("click", this._unspiderfyWrapper, this), this._map.options.zoomAnimation && this._map.on("zoomstart", this._unspiderfyZoomStart, this), this._map.on("zoomend", this._noanimationUnspiderfy, this), u.Browser.touch || this._map.getRenderer(this);
   },
   _spiderfierOnRemove: function() {
-    this._map.off("click", this._unspiderfyWrapper, this);
-    this._map.off("zoomstart", this._unspiderfyZoomStart, this);
-    this._map.off("zoomanim", this._unspiderfyZoomAnim, this);
-    this._map.off("zoomend", this._noanimationUnspiderfy, this);
-    this._noanimationUnspiderfy();
+    this._map.off("click", this._unspiderfyWrapper, this), this._map.off("zoomstart", this._unspiderfyZoomStart, this), this._map.off("zoomanim", this._unspiderfyZoomAnim, this), this._map.off("zoomend", this._noanimationUnspiderfy, this), this._noanimationUnspiderfy();
   },
   //On zoom start we add a zoomanim handler so that we are guaranteed to be last (after markers are animated)
   //This means we can define the animation they do rather than Markers doing an animation to their actual location
   _unspiderfyZoomStart: function() {
-    if (!this._map) {
-      return;
-    }
-    this._map.on("zoomanim", this._unspiderfyZoomAnim, this);
+    this._map && this._map.on("zoomanim", this._unspiderfyZoomAnim, this);
   },
-  _unspiderfyZoomAnim: function(zoomDetails) {
-    if (this._map._mapPane.classList.contains("leaflet-touching")) {
-      return;
-    }
-    this._map.off("zoomanim", this._unspiderfyZoomAnim, this);
-    this._unspiderfy(zoomDetails);
+  _unspiderfyZoomAnim: function(t) {
+    this._map._mapPane.classList.contains("leaflet-touching") || (this._map.off("zoomanim", this._unspiderfyZoomAnim, this), this._unspiderfy(t));
   },
   _unspiderfyWrapper: function() {
     this._unspiderfy();
   },
-  _unspiderfy: function(zoomDetails) {
-    if (this._spiderfied) {
-      this._spiderfied.unspiderfy(zoomDetails);
-    }
+  _unspiderfy: function(t) {
+    this._spiderfied && this._spiderfied.unspiderfy(t);
   },
   _noanimationUnspiderfy: function() {
-    if (this._spiderfied) {
-      this._spiderfied._noanimationUnspiderfy();
-    }
+    this._spiderfied && this._spiderfied._noanimationUnspiderfy();
   },
   //If the given layer is currently being spiderfied then we unspiderfy it so it isn't on the map anymore etc
-  _unspiderfyLayer: function(layer) {
-    if (layer._spiderLeg) {
-      this._featureGroup.removeLayer(layer);
-      if (layer.clusterShow) {
-        layer.clusterShow();
-      }
-      if (layer.setZIndexOffset) {
-        layer.setZIndexOffset(0);
-      }
-      this._map.removeLayer(layer._spiderLeg);
-      delete layer._spiderLeg;
-    }
+  _unspiderfyLayer: function(t) {
+    t._spiderLeg && (this._featureGroup.removeLayer(t), t.clusterShow && t.clusterShow(), t.setZIndexOffset && t.setZIndexOffset(0), this._map.removeLayer(t._spiderLeg), delete t._spiderLeg);
   }
 });
-L.MarkerClusterGroup.include({
+u.MarkerClusterGroup.include({
   /**
    * Updates the icon of all clusters which are parents of the given marker(s).
    * In singleMarkerMode, also updates the given marker(s) icon.
@@ -1957,39 +1107,19 @@ L.MarkerClusterGroup.include({
    * clusters need to be updated. If not provided, retrieves all child markers of this.
    * @returns {L.MarkerClusterGroup}
    */
-  refreshClusters: function(layers) {
-    if (!layers) {
-      layers = this._topClusterLevel.getAllChildMarkers();
-    } else if (layers instanceof L.MarkerClusterGroup) {
-      layers = layers._topClusterLevel.getAllChildMarkers();
-    } else if (layers instanceof L.LayerGroup) {
-      layers = layers._layers;
-    } else if (layers instanceof L.MarkerCluster) {
-      layers = layers.getAllChildMarkers();
-    } else if (layers instanceof L.Marker) {
-      layers = [layers];
-    }
-    this._flagParentsIconsNeedUpdate(layers);
-    this._refreshClustersIcons();
-    if (this.options.singleMarkerMode) {
-      this._refreshSingleMarkerModeMarkers(layers);
-    }
-    return this;
+  refreshClusters: function(t) {
+    return t ? t instanceof u.MarkerClusterGroup ? t = t._topClusterLevel.getAllChildMarkers() : t instanceof u.LayerGroup ? t = t._layers : t instanceof u.MarkerCluster ? t = t.getAllChildMarkers() : t instanceof u.Marker && (t = [t]) : t = this._topClusterLevel.getAllChildMarkers(), this._flagParentsIconsNeedUpdate(t), this._refreshClustersIcons(), this.options.singleMarkerMode && this._refreshSingleMarkerModeMarkers(t), this;
   },
   /**
    * Simply flags all parent clusters of the given markers as having a "dirty" icon.
    * @param layers Array(L.Marker)|Map(L.Marker) list of markers.
    * @private
    */
-  _flagParentsIconsNeedUpdate: (layers) => {
-    var id, parent;
-    for (id in layers) {
-      parent = layers[id].__parent;
-      while (parent) {
-        parent._iconNeedsUpdate = true;
-        parent = parent.__parent;
-      }
-    }
+  _flagParentsIconsNeedUpdate: (t) => {
+    var e, i;
+    for (e in t)
+      for (i = t[e].__parent; i; )
+        i._iconNeedsUpdate = !0, i = i.__parent;
   },
   /**
    * Re-draws the icon of the supplied markers.
@@ -1997,17 +1127,13 @@ L.MarkerClusterGroup.include({
    * @param layers Array(L.Marker)|Map(L.Marker) list of markers.
    * @private
    */
-  _refreshSingleMarkerModeMarkers: function(layers) {
-    var id, layer;
-    for (id in layers) {
-      layer = layers[id];
-      if (this.hasLayer(layer)) {
-        layer.setIcon(this._overrideMarkerIcon(layer));
-      }
-    }
+  _refreshSingleMarkerModeMarkers: function(t) {
+    var e, i;
+    for (e in t)
+      i = t[e], this.hasLayer(i) && i.setIcon(this._overrideMarkerIcon(i));
   }
 });
-L.Marker.include({
+u.Marker.include({
   /**
    * Updates the given options in the marker's icon and refreshes the marker.
    * @param options map object of icon options.
@@ -2015,14 +1141,9 @@ L.Marker.include({
    * MCG.refreshClustersOf() right away with this single marker.
    * @returns {L.Marker}
    */
-  refreshIconOptions: function(options, directlyRefreshClusters) {
-    var icon = this.options.icon;
-    L.setOptions(icon, options);
-    this.setIcon(icon);
-    if (directlyRefreshClusters && this.__parent) {
-      this.__parent._group.refreshClusters(this);
-    }
-    return this;
+  refreshIconOptions: function(t, e) {
+    var i = this.options.icon;
+    return u.setOptions(i, t), this.setIcon(i), e && this.__parent && this.__parent._group.refreshClusters(this), this;
   }
 });
 //# sourceMappingURL=cluster.js.map