@mattilsynet/design 2.2.24 → 2.2.25

package/mtds/atlas/cluster.js

@@ -1,30 +1,30 @@
-import u from "../external/leaflet/dist/leaflet-src.js";
-u.MarkerClusterGroup = u.FeatureGroup.extend({
+import L from "../external/leaflet/dist/leaflet-src.js";
+L.MarkerClusterGroup = L.FeatureGroup.extend({
   options: {
     maxClusterRadius: 80,
     //A cluster will cover at most this many pixels from its center
     iconCreateFunction: null,
-    spiderfyOnMaxZoom: !0,
-    showCoverageOnHover: !0,
-    zoomToBoundsOnClick: !0,
-    singleMarkerMode: !1,
+    spiderfyOnMaxZoom: true,
+    showCoverageOnHover: true,
+    zoomToBoundsOnClick: true,
+    singleMarkerMode: false,
     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: !0,
+    removeOutsideVisibleBounds: true,
     // 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: !0,
+    animate: true,
     //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: !1,
+    animateAddingMarkers: false,
     //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: !1,
+    chunkedLoading: false,
     chunkInterval: 200,
     // process markers for a maximum of ~ n milliseconds (then trigger the chunkProgress callback)
     chunkDelay: 50,
@@ -34,211 +34,457 @@ u.MarkerClusterGroup = u.FeatureGroup.extend({
     //Options to pass to the L.Polygon constructor
     polygonOptions: {}
   },
-  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 = {
+  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 = {
       dragstart: this._childMarkerDragStart,
       move: this._childMarkerMoved,
       dragend: this._childMarkerDragEnd
     };
-    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))
+    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 });
       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;
+    }
+    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;
   },
-  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);
+  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;
   },
   //Takes an array of markers and adds them in bulk
-  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;
+  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;
     if (this._map) {
-      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;
+      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;
             continue;
           }
-          if (!l.getLatLng) {
-            n.addLayer(l), e || this.fire("layeradd", { layer: l, propagatedFrom: l });
+          if (!m.getLatLng) {
+            npg.addLayer(m);
+            if (!skipLayerAddEvent) {
+              this.fire("layeradd", { layer: m, propagatedFrom: m });
+            }
             continue;
           }
-          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 (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);
+            }
           }
         }
-        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);
+        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);
+        }
       };
-      p();
+      process();
     } else {
-      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;
+      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);
           continue;
         }
-        if (!l.getLatLng) {
-          n.addLayer(l);
+        if (this.hasLayer(m)) {
           continue;
         }
-        this.hasLayer(l) || d.push(l);
+        needsClustering.push(m);
       }
     }
     return this;
   },
   //Takes an array of markers and removes them in bulk
-  removeLayers: function(t) {
-    var e, i, n = t.length, s = this._featureGroup, o = this._nonPointGroup, r = !0;
+  removeLayers: function(layersArray) {
+    var i, m, l = layersArray.length, fg = this._featureGroup, npg = this._nonPointGroup, originalArray = true;
     if (!this._map) {
-      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;
+      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;
           continue;
         }
-        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 });
+        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 });
       }
       return this;
     }
     if (this._unspiderfy) {
       this._unspiderfy();
-      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;
+      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;
           continue;
         }
-        this._unspiderfyLayer(i);
+        this._unspiderfyLayer(m);
       }
     }
-    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;
+    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;
         continue;
       }
-      if (!i.__parent) {
-        o.removeLayer(i), this.fire("layerremove", { layer: i, propagatedFrom: i });
+      if (!m.__parent) {
+        npg.removeLayer(m);
+        this.fire("layerremove", { layer: m, propagatedFrom: m });
         continue;
       }
-      this._removeLayer(i, !0, !0), this.fire("layerremove", { layer: i, propagatedFrom: i }), s.hasLayer(i) && (s.removeLayer(i), i.clusterShow && i.clusterShow());
+      this._removeLayer(m, true, true);
+      this.fire("layerremove", { layer: m, propagatedFrom: m });
+      if (fg.hasLayer(m)) {
+        fg.removeLayer(m);
+        if (m.clusterShow) {
+          m.clusterShow();
+        }
+      }
     }
-    return this._topClusterLevel._recalculateBounds(), this._refreshClustersIcons(), this._topClusterLevel._recursivelyAddChildrenToMap(
+    this._topClusterLevel._recalculateBounds();
+    this._refreshClustersIcons();
+    this._topClusterLevel._recursivelyAddChildrenToMap(
       null,
       this._zoom,
       this._currentShownBounds
-    ), this;
+    );
+    return this;
   },
   //Removes all layers from the MarkerClusterGroup
   clearLayers: function() {
-    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;
+    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;
   },
   //Override FeatureGroup.getBounds as it doesn't work
   getBounds: function() {
-    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;
+    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;
   },
   //Overrides LayerGroup.eachLayer
-  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;
+  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;
           break;
         }
-      s && t.call(e, i[o]);
+      }
+      if (thisNeedsRemoving) {
+        method.call(context, markers[i]);
+      }
     }
-    this._nonPointGroup.eachLayer(t, e);
+    this._nonPointGroup.eachLayer(method, context);
   },
   //Overrides LayerGroup.getLayers
   getLayers: function() {
-    var t = [];
-    return this.eachLayer((e) => {
-      t.push(e);
-    }), t;
+    var layers = [];
+    this.eachLayer((l) => {
+      layers.push(l);
+    });
+    return layers;
   },
   //Overrides LayerGroup.getLayer, WARNING: Really bad performance
-  getLayer: function(t) {
-    var e = null;
-    return t = parseInt(t, 10), this.eachLayer((i) => {
-      u.stamp(i) === t && (e = i);
-    }), e;
+  getLayer: function(id) {
+    var result = null;
+    id = parseInt(id, 10);
+    this.eachLayer((l) => {
+      if (L.stamp(l) === id) {
+        result = l;
+      }
+    });
+    return result;
   },
   //Returns true if the given layer is in this MarkerClusterGroup
-  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);
+  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);
   },
   //Zoom down to show the given layer (spiderfying if necessary) then calls the callback
-  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()));
+  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();
+        }
+      }
     };
-    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());
+    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();
+    }
   },
   //Overrides FeatureGroup.onAdd
-  onAdd: function(t) {
-    this._map = t;
-    var e, i, n;
-    if (!Number.isFinite(this._map.getMaxZoom()))
+  onAdd: function(map) {
+    this._map = map;
+    var i, l, layer;
+    if (!Number.isFinite(this._map.getMaxZoom())) {
       throw "Map has no maxZoom specified";
-    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);
+    }
+    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);
   },
   //Overrides FeatureGroup.onRemove
-  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(
+  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(
       " leaflet-cluster-anim",
       ""
-    ), 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;
+    );
+    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;
   },
   //Remove the given object from the given array
-  _arraySplice: (t, e) => {
-    for (let i = t.length - 1; i >= 0; i--)
-      if (t[i] === e)
-        return t.splice(i, 1), !0;
+  _arraySplice: (anArray, obj) => {
+    for (let i = anArray.length - 1; i >= 0; i--) {
+      if (anArray[i] === obj) {
+        anArray.splice(i, 1);
+        return true;
+      }
+    }
   },
   /**
    * Removes a marker from all _gridUnclustered zoom levels, starting at the supplied zoom.
@@ -246,157 +492,269 @@ u.MarkerClusterGroup = u.FeatureGroup.extend({
    * @param z integer bottom start zoom level (included)
    * @private
    */
-  _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--)
-      ;
+  _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;
+      }
+    }
   },
-  _childMarkerDragStart: (t) => {
-    t.target.__dragStart = t.target._latlng;
+  _childMarkerDragStart: (e) => {
+    e.target.__dragStart = e.target._latlng;
   },
-  _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();
+  _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();
+      }
     }
   },
-  _moveChild: function(t, e, i) {
-    t._latlng = e, this.removeLayer(t), t._latlng = i, this.addLayer(t);
+  _moveChild: function(layer, from, to) {
+    layer._latlng = from;
+    this.removeLayer(layer);
+    layer._latlng = to;
+    this.addLayer(layer);
   },
-  _childMarkerDragEnd: function(t) {
-    t.target.__dragStart && this._moveChild(t.target, t.target.__dragStart, t.target._latlng), delete t.target.__dragStart;
+  _childMarkerDragEnd: function(e) {
+    if (e.target.__dragStart) {
+      this._moveChild(e.target, e.target.__dragStart, e.target._latlng);
+    }
+    delete e.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(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;
+  _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;
   },
   //Override L.Evented.fire
-  fire: function(t, e, i) {
-    if (e && e.propagatedFrom instanceof u.MarkerCluster) {
+  fire: function(type, e, propagate) {
+    if (e && e.propagatedFrom instanceof L.MarkerCluster) {
       if (e.originalEvent && this._isOrIsParent(
         e.propagatedFrom._icon,
         e.originalEvent.relatedTarget
       ))
         return;
-      t = `cluster${t}`;
+      type = `cluster${type}`;
     }
-    u.FeatureGroup.prototype.fire.call(this, t, e, i);
+    L.FeatureGroup.prototype.fire.call(this, type, e, propagate);
   },
   //Override L.Evented.listens
-  listens: function(t, e) {
-    return u.FeatureGroup.prototype.listens.call(this, t, e) || u.FeatureGroup.prototype.listens.call(this, `cluster${t}`, e);
+  listens: function(type, propagate) {
+    return L.FeatureGroup.prototype.listens.call(this, type, propagate) || L.FeatureGroup.prototype.listens.call(this, `cluster${type}`, propagate);
   },
   //Default functionality
-  _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)
+  _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)
     });
   },
   _bindEvents: function() {
-    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)));
+    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);
+    }
   },
   _hideCoverage: function() {
-    this._shownPolygon && (this._map.removeLayer(this._shownPolygon), this._shownPolygon = null);
+    if (this._shownPolygon) {
+      this._map.removeLayer(this._shownPolygon);
+      this._shownPolygon = null;
+    }
   },
   _unbindEvents: function() {
-    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));
+    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);
+    }
   },
   _zoomEnd: function() {
-    this._map && (this._mergeSplitClusters(), this._zoom = Math.round(this._map._zoom), this._currentShownBounds = this._getExpandedVisibleBounds());
+    if (!this._map) {
+      return;
+    }
+    this._mergeSplitClusters();
+    this._zoom = Math.round(this._map._zoom);
+    this._currentShownBounds = this._getExpandedVisibleBounds();
   },
   _moveEnd: function() {
-    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;
+    if (this._inZoomAnimation) {
+      return;
     }
+    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 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);
+    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);
   },
   //Zoom: Zoom to start adding at (Pass this._maxZoom to start at the bottom)
-  _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;
+  _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;
         return;
       }
-      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)
+      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)
           );
-        h._addChild(l), this._removeFromGridUnclustered(a, e);
+        }
+        parent._addChild(lastParent);
+        this._removeFromGridUnclustered(closest, zoom);
         return;
       }
-      n[e].addObject(t, o);
+      gridUnclustered[zoom].addObject(layer, markerPoint);
     }
-    this._topClusterLevel._addChild(t), t.__parent = this._topClusterLevel;
+    this._topClusterLevel._addChild(layer);
+    layer.__parent = this._topClusterLevel;
+    return;
   },
   /**
    * Refreshes the icon of all "dirty" visible clusters.
@@ -404,35 +762,54 @@ u.MarkerClusterGroup = u.FeatureGroup.extend({
    * @private
    */
   _refreshClustersIcons: function() {
-    this._featureGroup.eachLayer((t) => {
-      t instanceof u.MarkerCluster && t._iconNeedsUpdate && t._updateIcon();
+    this._featureGroup.eachLayer((c) => {
+      if (c instanceof L.MarkerCluster && c._iconNeedsUpdate) {
+        c._updateIcon();
+      }
     });
   },
   //Enqueue code to fire after the marker expand/contract has happened
-  _enqueue: function(t) {
-    this._queue.push(t), this._queueTimeout || (this._queueTimeout = setTimeout(() => this._processQueue(), 300));
+  _enqueue: function(fn) {
+    this._queue.push(fn);
+    if (!this._queueTimeout) {
+      this._queueTimeout = setTimeout(() => this._processQueue(), 300);
+    }
   },
   _processQueue: function() {
-    for (let t = 0; t < this._queue.length; t++)
-      this._queue[t].call(this);
-    this._queue.length = 0, clearTimeout(this._queueTimeout), this._queueTimeout = null;
+    for (let i = 0; i < this._queue.length; i++) {
+      this._queue[i].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 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();
+    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();
+    }
   },
   //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) {
-      if (u.Browser.mobile)
-        return this._checkBoundsMaxLat(this._map.getBounds());
-    } else return this._mapBoundsInfinite;
+    if (!this.options.removeOutsideVisibleBounds) {
+      return this._mapBoundsInfinite;
+    } else if (L.Browser.mobile) {
+      return this._checkBoundsMaxLat(this._map.getBounds());
+    }
     return this._checkBoundsMaxLat(this._map.getBounds().pad(1));
   },
   /**
@@ -445,20 +822,30 @@ u.MarkerClusterGroup = u.FeatureGroup.extend({
    * @returns {L.LatLngBounds}
    * @private
    */
-  _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;
+  _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;
   },
   //Shared animation code
-  _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();
+  _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();
+    }
   },
   /**
    * Extracts individual (i.e. non-group) layers from a Layer Group.
@@ -467,16 +854,18 @@ u.MarkerClusterGroup = u.FeatureGroup.extend({
    * @returns {*|Array}
    * @private
    */
-  _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);
+  _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);
         continue;
       }
-      e.push(s);
+      output.push(layer);
     }
-    return e;
+    return output;
   },
   /**
    * Implements the singleMarkerMode option.
@@ -484,206 +873,318 @@ u.MarkerClusterGroup = u.FeatureGroup.extend({
    * @returns {L.Icon} The newly created icon.
    * @private
    */
-  _overrideMarkerIcon: function(t) {
-    return t.options.icon = this.options.iconCreateFunction({
+  _overrideMarkerIcon: function(layer) {
+    layer.options.icon = this.options.iconCreateFunction({
       getChildCount: () => 1,
-      getAllChildMarkers: () => [t]
-    }), t.options.icon;
+      getAllChildMarkers: () => [layer]
+    });
+    return layer.options.icon;
   }
 });
-u.MarkerClusterGroup.include({
-  _mapBoundsInfinite: new u.LatLngBounds(
-    new u.LatLng(-1 / 0, -1 / 0),
-    new u.LatLng(1 / 0, 1 / 0)
+L.MarkerClusterGroup.include({
+  _mapBoundsInfinite: new L.LatLngBounds(
+    new L.LatLng(-Infinity, -Infinity),
+    new L.LatLng(Infinity, Infinity)
   )
 });
-u.MarkerClusterGroup.include({
+L.MarkerClusterGroup.include({
   _noAnimation: {
     //Non Animated versions of everything
     _animationStart: () => {
     },
-    _animationZoomIn: function(t, e) {
+    _animationZoomIn: function(previousZoomLevel, newZoomLevel) {
       this._topClusterLevel._recursivelyRemoveChildrenFromMap(
         this._currentShownBounds,
         Math.floor(this._map.getMinZoom()),
-        t
-      ), this._topClusterLevel._recursivelyAddChildrenToMap(
+        previousZoomLevel
+      );
+      this._topClusterLevel._recursivelyAddChildrenToMap(
         null,
-        e,
+        newZoomLevel,
         this._getExpandedVisibleBounds()
-      ), this.fire("animationend");
+      );
+      this.fire("animationend");
     },
-    _animationZoomOut: function(t, e) {
+    _animationZoomOut: function(previousZoomLevel, newZoomLevel) {
       this._topClusterLevel._recursivelyRemoveChildrenFromMap(
         this._currentShownBounds,
         Math.floor(this._map.getMinZoom()),
-        t
-      ), this._topClusterLevel._recursivelyAddChildrenToMap(
+        previousZoomLevel
+      );
+      this._topClusterLevel._recursivelyAddChildrenToMap(
         null,
-        e,
+        newZoomLevel,
         this._getExpandedVisibleBounds()
-      ), this.fire("animationend");
+      );
+      this.fire("animationend");
     },
-    _animationAddLayer: function(t, e) {
-      this._animationAddLayerNonAnimated(t, e);
+    _animationAddLayer: function(layer, newCluster) {
+      this._animationAddLayerNonAnimated(layer, newCluster);
     }
   },
   _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(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(_);
+    _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);
+            }
+          }
         }
-      ), 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._forceLayout();
+      this._topClusterLevel._recursivelyBecomeVisible(bounds, newZoomLevel);
+      fg.eachLayer((n) => {
+        if (!(n instanceof L.MarkerCluster) && n._icon) {
+          n.clusterShow();
         }
-      ), this._ignoreMove = !1, this._enqueue(function() {
+      });
+      this._topClusterLevel._recursively(
+        bounds,
+        previousZoomLevel,
+        newZoomLevel,
+        (c) => {
+          c._recursivelyRestoreChildPositions(newZoomLevel);
+        }
+      );
+      this._ignoreMove = false;
+      this._enqueue(function() {
         this._topClusterLevel._recursively(
-          i,
-          t,
-          s,
-          (r) => {
-            n.removeLayer(r), r.clusterShow();
+          bounds,
+          previousZoomLevel,
+          minZoom,
+          (c) => {
+            fg.removeLayer(c);
+            c.clusterShow();
           }
-        ), this._animationEnd();
+        );
+        this._animationEnd();
       });
     },
-    _animationZoomOut: function(t, e) {
+    _animationZoomOut: function(previousZoomLevel, newZoomLevel) {
       this._animationZoomOutSingle(
         this._topClusterLevel,
-        t - 1,
-        e
-      ), this._topClusterLevel._recursivelyAddChildrenToMap(
+        previousZoomLevel - 1,
+        newZoomLevel
+      );
+      this._topClusterLevel._recursivelyAddChildrenToMap(
         null,
-        e,
+        newZoomLevel,
         this._getExpandedVisibleBounds()
-      ), this._topClusterLevel._recursivelyRemoveChildrenFromMap(
+      );
+      this._topClusterLevel._recursivelyRemoveChildrenFromMap(
         this._currentShownBounds,
         Math.floor(this._map.getMinZoom()),
-        t,
+        previousZoomLevel,
         this._getExpandedVisibleBounds()
       );
     },
-    _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
-      )));
+    _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
+          );
+        }
+      }
     }
   },
   // Private methods for animated versions.
-  _animationZoomOutSingle: function(t, e, i) {
-    var n = this._getExpandedVisibleBounds(), s = Math.floor(this._map.getMinZoom());
-    t._recursivelyAnimateChildrenInAndAddSelfToMap(
-      n,
-      s,
-      e + 1,
-      i
+  _animationZoomOutSingle: function(cluster, previousZoomLevel, newZoomLevel) {
+    var bounds = this._getExpandedVisibleBounds(), minZoom = Math.floor(this._map.getMinZoom());
+    cluster._recursivelyAnimateChildrenInAndAddSelfToMap(
+      bounds,
+      minZoom,
+      previousZoomLevel + 1,
+      newZoomLevel
     );
-    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
+    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
           );
         });
-      o._animationEnd();
+      }
+      me._animationEnd();
     });
   },
   _animationEnd: function() {
-    this._map && (this._map._mapPane.className = this._map._mapPane.className.replace(
-      " leaflet-cluster-anim",
-      ""
-    )), this._inZoomAnimation--, this.fire("animationend");
+    if (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: () => {
-    u.Util.falseFn(document.body.offsetWidth);
+    L.Util.falseFn(document.body.offsetWidth);
   }
 });
-u.MarkerCluster = u.Marker.extend({
-  initialize: function(t, e, i, n) {
-    u.Marker.prototype.initialize.call(
+L.MarkerCluster = L.Marker.extend({
+  initialize: function(group, zoom, a, b) {
+    L.Marker.prototype.initialize.call(
       this,
-      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);
+      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);
+    }
   },
   //Recursively retrieve all child markers of this cluster
-  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;
+  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;
   },
   //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(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;
+  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);
     }
-    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 t = new u.LatLngBounds();
-    return t.extend(this._bounds), t;
+    var bounds = new L.LatLngBounds();
+    bounds.extend(this._bounds);
+    return bounds;
   },
   _updateIcon: function() {
-    this._iconNeedsUpdate = !0, this._icon && this.setIcon(this);
+    this._iconNeedsUpdate = true;
+    if (this._icon) {
+      this.setIcon(this);
+    }
   },
   //Cludge for Icon, we pretend to be an icon for performance
   createIcon: function() {
-    return this._iconNeedsUpdate && (this._iconObj = this._group.options.iconCreateFunction(this), this._iconNeedsUpdate = !1), this._iconObj.createIcon();
+    if (this._iconNeedsUpdate) {
+      this._iconObj = this._group.options.iconCreateFunction(this);
+      this._iconNeedsUpdate = false;
+    }
+    return this._iconObj.createIcon();
   },
   createShadow: function() {
     return this._iconObj.createShadow();
   },
-  _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);
+  _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);
+    }
   },
   /**
    * 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(t) {
-    this._cLatLng || (this._cLatLng = t._cLatLng || t._latlng);
+  _setClusterCenter: function(child) {
+    if (!this._cLatLng) {
+      this._cLatLng = child._cLatLng || child._latlng;
+    }
   },
   /**
    * Assigns impossible bounding values so that the next extend entirely determines the new bounds.
@@ -692,113 +1193,192 @@ u.MarkerCluster = u.Marker.extend({
    * @private
    */
   _resetBounds: function() {
-    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);
+    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;
+    }
   },
   _recalculateBounds: function() {
-    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;
+    var markers = this._markers, childClusters = this._childClusters, latSum = 0, lngSum = 0, totalCount = this._childCount, i, child, childLatLng, childCount;
+    if (totalCount === 0) {
+      return;
     }
+    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(t) {
-    t && (this._backupLatlng = this._latlng, this.setLatLng(t)), this._group._featureGroup.addLayer(this);
+  _addToMap: function(startPos) {
+    if (startPos) {
+      this._backupLatlng = this._latlng;
+      this.setLatLng(startPos);
+    }
+    this._group._featureGroup.addLayer(this);
   },
-  _recursivelyAnimateChildrenIn: function(t, e, i) {
+  _recursivelyAnimateChildrenIn: function(bounds, center, maxZoom) {
     this._recursively(
-      t,
+      bounds,
       this._group._map.getMinZoom(),
-      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());
+      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();
+          }
+        }
       },
-      (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());
+      (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();
+          }
+        }
       }
     );
   },
-  _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();
+  _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();
     });
   },
-  _recursivelyBecomeVisible: function(t, e) {
+  _recursivelyBecomeVisible: function(bounds, zoomLevel) {
     this._recursively(
-      t,
+      bounds,
       this._group._map.getMinZoom(),
-      e,
+      zoomLevel,
       null,
-      (i) => {
-        i.clusterShow();
+      (c) => {
+        c.clusterShow();
       }
     );
   },
-  _recursivelyAddChildrenToMap: function(t, e, i) {
+  _recursivelyAddChildrenToMap: function(startPos, zoomLevel, bounds) {
     this._recursively(
-      i,
+      bounds,
       this._group._map.getMinZoom() - 1,
-      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));
+      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();
+            }
           }
+          c._group._featureGroup.addLayer(nm);
+        }
       },
-      (n) => {
-        n._addToMap(t);
+      (c) => {
+        c._addToMap(startPos);
       }
     );
   },
-  _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);
+  _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);
+      }
     }
-    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() {
-    this._backupLatlng && (this.setLatLng(this._backupLatlng), delete this._backupLatlng);
+    if (this._backupLatlng) {
+      this.setLatLng(this._backupLatlng);
+      delete this._backupLatlng;
+    }
   },
   //exceptBounds: If set, don't remove any markers/clusters in it
-  _recursivelyRemoveChildrenFromMap: function(t, e, i, n) {
-    var s, o;
+  _recursivelyRemoveChildrenFromMap: function(previousBounds, mapMinZoom, zoomLevel, exceptBounds) {
+    var m, i;
     this._recursively(
-      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());
+      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();
+            }
+          }
+        }
       },
-      (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());
+      (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();
+            }
+          }
+        }
       }
     );
   },
@@ -808,162 +1388,250 @@ u.MarkerCluster = u.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(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
-        );
+  _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
+          );
+        }
+      }
+    }
   },
   //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;
   }
 });
-u.Marker.include({
+L.Marker.include({
   clusterHide: function() {
-    return this.options.opacityWhenUnclustered = this.options.opacity || 1, this.setOpacity(0);
+    this.options.opacityWhenUnclustered = this.options.opacity || 1;
+    return this.setOpacity(0);
   },
   clusterShow: function() {
-    var t = this.setOpacity(
+    var ret = this.setOpacity(
       this.options.opacity || this.options.opacityWhenUnclustered
     );
-    return delete this.options.opacityWhenUnclustered, t;
+    delete this.options.opacityWhenUnclustered;
+    return ret;
   }
 });
-u.DistanceGrid = function(t) {
-  this._cellSize = t, this._sqCellSize = t * t, this._grid = {}, this._objectPoint = {};
+L.DistanceGrid = function(cellSize) {
+  this._cellSize = cellSize;
+  this._sqCellSize = cellSize * cellSize;
+  this._grid = {};
+  this._objectPoint = {};
 };
-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);
+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);
   },
   //Returns true if the object was found
-  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);
+  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;
+      }
     }
-    return { maxPoint: n, newPoints: s };
   },
-  /*
-   * 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;
+  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;
+              }
+            }
+          }
+        }
+      }
+    }
+    return closest;
+  },
+  _getCoord: function(x) {
+    return Math.floor(x / this._cellSize);
+  },
+  _sqDist: (p, p2) => {
+    var dx = p2.x - p.x, dy = p2.y - p.y;
+    return dx * dx + dy * dy;
   }
 };
-u.MarkerCluster.include({
+(() => {
+  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({
   getConvexHull: function() {
-    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);
+    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);
   }
 });
-u.MarkerCluster.include({
+L.MarkerCluster.include({
   _2PI: Math.PI * 2,
   _circleFootSeparation: 25,
   //related to circumference of circle
@@ -976,129 +1644,311 @@ u.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)) {
-      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);
+    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);
+    }
+    this._animationSpiderfy(childMarkers, positions);
   },
-  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)
+  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 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;
+    }
+    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)
+      )._round();
+      legLength += lengthFactor / angle;
+    }
+    return res;
   },
   _noanimationUnspiderfy: function() {
-    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", {
+    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", {
       cluster: this,
-      markers: n
-    }), t._ignoreMove = !1, t._spiderfied = null;
+      markers: childMarkers
+    });
+    group._ignoreMove = false;
+    group._spiderfied = null;
   }
 });
-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", {
+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", {
       cluster: this,
-      markers: t
+      markers: childMarkers
     });
   },
   _animationUnspiderfy: function() {
     this._noanimationUnspiderfy();
   }
 });
-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(
+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(
       {},
       this._group.options.spiderLegPolylineOptions
-    ), _ = 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", {
+    ), 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", {
         cluster: this,
-        markers: t
+        markers: childMarkers
       });
     }, 200);
   },
-  _animationUnspiderfy: function(t) {
-    var e = this._group, i = e._map, n = e._featureGroup, s = t ? i._latLngToNewLayerPoint(
+  _animationUnspiderfy: function(zoomDetails) {
+    var group = this._group, map = group._map, fg = group._featureGroup, thisLayerPos = zoomDetails ? map._latLngToNewLayerPoint(
       this._latlng,
-      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", {
+      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", {
         cluster: this,
-        markers: o
+        markers: childMarkers
       });
     }, 200);
   }
 });
-u.MarkerClusterGroup.include({
+L.MarkerClusterGroup.include({
   //The MarkerCluster currently spiderfied (if any)
   _spiderfied: null,
-  unspiderfy: function(...t) {
-    this._unspiderfy.apply(this, t);
+  unspiderfy: function(...args) {
+    this._unspiderfy.apply(this, args);
   },
   _spiderfierOnAdd: function() {
-    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);
+    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);
+    }
   },
   _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() {
-    this._map && this._map.on("zoomanim", this._unspiderfyZoomAnim, this);
+    if (!this._map) {
+      return;
+    }
+    this._map.on("zoomanim", this._unspiderfyZoomAnim, this);
   },
-  _unspiderfyZoomAnim: function(t) {
-    this._map._mapPane.classList.contains("leaflet-touching") || (this._map.off("zoomanim", this._unspiderfyZoomAnim, this), this._unspiderfy(t));
+  _unspiderfyZoomAnim: function(zoomDetails) {
+    if (this._map._mapPane.classList.contains("leaflet-touching")) {
+      return;
+    }
+    this._map.off("zoomanim", this._unspiderfyZoomAnim, this);
+    this._unspiderfy(zoomDetails);
   },
   _unspiderfyWrapper: function() {
     this._unspiderfy();
   },
-  _unspiderfy: function(t) {
-    this._spiderfied && this._spiderfied.unspiderfy(t);
+  _unspiderfy: function(zoomDetails) {
+    if (this._spiderfied) {
+      this._spiderfied.unspiderfy(zoomDetails);
+    }
   },
   _noanimationUnspiderfy: function() {
-    this._spiderfied && this._spiderfied._noanimationUnspiderfy();
+    if (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(t) {
-    t._spiderLeg && (this._featureGroup.removeLayer(t), t.clusterShow && t.clusterShow(), t.setZIndexOffset && t.setZIndexOffset(0), this._map.removeLayer(t._spiderLeg), delete t._spiderLeg);
+  _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;
+    }
   }
 });
-u.MarkerClusterGroup.include({
+L.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.
@@ -1107,19 +1957,39 @@ u.MarkerClusterGroup.include({
    * clusters need to be updated. If not provided, retrieves all child markers of this.
    * @returns {L.MarkerClusterGroup}
    */
-  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;
+  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;
   },
   /**
    * 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: (t) => {
-    var e, i;
-    for (e in t)
-      for (i = t[e].__parent; i; )
-        i._iconNeedsUpdate = !0, i = i.__parent;
+  _flagParentsIconsNeedUpdate: (layers) => {
+    var id, parent;
+    for (id in layers) {
+      parent = layers[id].__parent;
+      while (parent) {
+        parent._iconNeedsUpdate = true;
+        parent = parent.__parent;
+      }
+    }
   },
   /**
    * Re-draws the icon of the supplied markers.
@@ -1127,13 +1997,17 @@ u.MarkerClusterGroup.include({
    * @param layers Array(L.Marker)|Map(L.Marker) list of markers.
    * @private
    */
-  _refreshSingleMarkerModeMarkers: function(t) {
-    var e, i;
-    for (e in t)
-      i = t[e], this.hasLayer(i) && i.setIcon(this._overrideMarkerIcon(i));
+  _refreshSingleMarkerModeMarkers: function(layers) {
+    var id, layer;
+    for (id in layers) {
+      layer = layers[id];
+      if (this.hasLayer(layer)) {
+        layer.setIcon(this._overrideMarkerIcon(layer));
+      }
+    }
   }
 });
-u.Marker.include({
+L.Marker.include({
   /**
    * Updates the given options in the marker's icon and refreshes the marker.
    * @param options map object of icon options.
@@ -1141,9 +2015,14 @@ u.Marker.include({
    * MCG.refreshClustersOf() right away with this single marker.
    * @returns {L.Marker}
    */
-  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;
+  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;
   }
 });
 //# sourceMappingURL=cluster.js.map