@mattilsynet/design 2.2.19 → 2.2.21

package/mtds/atlas/cluster.js

@@ -0,0 +1,1149 @@
+import u from "../external/leaflet/dist/leaflet-src.js";
+u.MarkerClusterGroup = u.FeatureGroup.extend({
+  options: {
+    maxClusterRadius: 80,
+    //A cluster will cover at most this many pixels from its center
+    iconCreateFunction: null,
+    spiderfyOnMaxZoom: !0,
+    showCoverageOnHover: !0,
+    zoomToBoundsOnClick: !0,
+    singleMarkerMode: !1,
+    disableClusteringAtZoom: null,
+    // Setting this to false prevents the removal of any clusters outside of the viewpoint, which
+    // is the default behaviour for performance reasons.
+    removeOutsideVisibleBounds: !0,
+    // Set to false to disable all animations (zoom and spiderfy).
+    // If false, option animateAddingMarkers below has no effect.
+    // If L.DomUtil.TRANSITION is falsy, this option has no effect.
+    animate: !0,
+    //Whether to animate adding markers after adding the MarkerClusterGroup to the map
+    // If you are adding individual markers set to true, if adding bulk markers leave false for massive performance gains.
+    animateAddingMarkers: !1,
+    //Increase to increase the distance away that spiderfied markers appear from the center
+    spiderfyDistanceMultiplier: 1,
+    // Make it possible to specify a polyline options on a spider leg
+    spiderLegPolylineOptions: { weight: 1.5, color: "#222", opacity: 0.5 },
+    // When bulk adding layers, adds markers in chunks. Means addLayers may not add all the layers in the call, others will be loaded during setTimeouts
+    chunkedLoading: !1,
+    chunkInterval: 200,
+    // process markers for a maximum of ~ n milliseconds (then trigger the chunkProgress callback)
+    chunkDelay: 50,
+    // at the end of each interval, give n milliseconds back to system/browser
+    chunkProgress: null,
+    // progress callback: function(processed, total, elapsed) (e.g. for a progress indicator)
+    //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 = {
+      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))
+      return this;
+    this._unspiderfy && this._unspiderfy(), this._addLayer(t, this._maxZoom), this.fire("layeradd", { layer: t }), this._topClusterLevel._recalculateBounds(), this._refreshClustersIcons();
+    var e = t, i = this._zoom;
+    if (t.__parent)
+      for (; e.__parent._zoom >= i; )
+        e = e.__parent;
+    return this._currentShownBounds.contains(e.getLatLng()) && (this.options.animateAddingMarkers ? this._animationAddLayer(t, e) : this._animationAddLayerNonAnimated(t, e)), this;
+  },
+  removeLayer: function(t) {
+    return t instanceof u.LayerGroup ? this.removeLayers([t]) : t.getLatLng ? this._map ? t.__parent ? (this._unspiderfy && (this._unspiderfy(), this._unspiderfyLayer(t)), this._removeLayer(t, !0), this.fire("layerremove", { layer: t, propagatedFrom: t }), this._topClusterLevel._recalculateBounds(), this._refreshClustersIcons(), t.off(this._childMarkerEventHandlers, this), this._featureGroup.hasLayer(t) && (this._featureGroup.removeLayer(t), t.clusterShow && t.clusterShow()), this) : this : (!this._arraySplice(this._needsClustering, t) && this.hasLayer(t) && this._needsRemoving.push({ layer: t, latlng: t._latlng }), this.fire("layerremove", { layer: t, propagatedFrom: t }), this) : (this._nonPointGroup.removeLayer(t), this.fire("layerremove", { layer: t, propagatedFrom: t }), this);
+  },
+  //Takes an array of markers and adds them in bulk
+  addLayers: function(t, e) {
+    if (!Array.isArray(t)) return this.addLayer(t);
+    var i = this._featureGroup, n = this._nonPointGroup, s = this.options.chunkedLoading, o = this.options.chunkInterval, r = this.options.chunkProgress, a = t.length, h = 0, _ = !0, l;
+    if (this._map) {
+      const d = Date.now(), p = () => {
+        for (var f = Date.now(); h < a && !(s && h % 200 === 0 && Date.now() - f > o); h++) {
+          if (l = t[h], l instanceof u.LayerGroup) {
+            _ && (t = t.slice(), _ = !1), this._extractNonGroupLayers(l, t), a = t.length;
+            continue;
+          }
+          if (!l.getLatLng) {
+            n.addLayer(l), e || this.fire("layeradd", { layer: l, propagatedFrom: l });
+            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);
+          }
+        }
+        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);
+      };
+      p();
+    } 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;
+          continue;
+        }
+        if (!l.getLatLng) {
+          n.addLayer(l);
+          continue;
+        }
+        this.hasLayer(l) || d.push(l);
+      }
+    }
+    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;
+    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;
+          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 });
+      }
+      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;
+          continue;
+        }
+        this._unspiderfyLayer(i);
+      }
+    }
+    for (e = 0; e < n; e++) {
+      if (i = t[e], i instanceof u.LayerGroup) {
+        r && (t = t.slice(), r = !1), this._extractNonGroupLayers(i, t), n = t.length;
+        continue;
+      }
+      if (!i.__parent) {
+        o.removeLayer(i), this.fire("layerremove", { layer: i, propagatedFrom: i });
+        continue;
+      }
+      this._removeLayer(i, !0, !0), this.fire("layerremove", { layer: i, propagatedFrom: i }), s.hasLayer(i) && (s.removeLayer(i), i.clusterShow && i.clusterShow());
+    }
+    return this._topClusterLevel._recalculateBounds(), this._refreshClustersIcons(), this._topClusterLevel._recursivelyAddChildrenToMap(
+      null,
+      this._zoom,
+      this._currentShownBounds
+    ), 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;
+  },
+  //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;
+  },
+  //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;
+          break;
+        }
+      s && t.call(e, i[o]);
+    }
+    this._nonPointGroup.eachLayer(t, e);
+  },
+  //Overrides LayerGroup.getLayers
+  getLayers: function() {
+    var t = [];
+    return this.eachLayer((e) => {
+      t.push(e);
+    }), t;
+  },
+  //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;
+  },
+  //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);
+  },
+  //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()));
+    };
+    t._icon && this._map.getBounds().contains(t.getLatLng()) ? e() : t.__parent._zoom < Math.round(this._map._zoom) ? (this._map.on("moveend", i, this), this._map.panTo(t.getLatLng())) : (this._map.on("moveend", i, this), this.on("animationend", i, this), t.__parent.zoomToBounds());
+  },
+  //Overrides FeatureGroup.onAdd
+  onAdd: function(t) {
+    this._map = t;
+    var e, i, n;
+    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);
+  },
+  //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(
+      " 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;
+  },
+  //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;
+  },
+  /**
+   * Removes a marker from all _gridUnclustered zoom levels, starting at the supplied zoom.
+   * @param marker to be removed from _gridUnclustered.
+   * @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--)
+      ;
+  },
+  _childMarkerDragStart: (t) => {
+    t.target.__dragStart = t.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();
+    }
+  },
+  _moveChild: function(t, e, i) {
+    t._latlng = e, this.removeLayer(t), t._latlng = i, this.addLayer(t);
+  },
+  _childMarkerDragEnd: function(t) {
+    t.target.__dragStart && this._moveChild(t.target, t.target.__dragStart, t.target._latlng), delete t.target.__dragStart;
+  },
+  //Internal function for removing a marker from everything.
+  //dontUpdateMap: set to true if you will handle updating the map manually (for bulk functions)
+  _removeLayer: function(t, e, i) {
+    var n = this._gridClusters, s = this._gridUnclustered, o = this._featureGroup, r = this._map, a = Math.floor(this._map.getMinZoom());
+    e && this._removeFromGridUnclustered(t, this._maxZoom);
+    var h = t.__parent, _ = h._markers, l;
+    for (this._arraySplice(_, t); h && (h._childCount--, h._boundsNeedUpdate = !0, !(h._zoom < a)); )
+      e && h._childCount <= 1 ? (l = h._markers[0] === t ? h._markers[1] : h._markers[0], n[h._zoom].removeObject(
+        h,
+        r.project(h._cLatLng, h._zoom)
+      ), s[h._zoom].addObject(
+        l,
+        r.project(l.getLatLng(), h._zoom)
+      ), this._arraySplice(h.__parent._childClusters, h), h.__parent._markers.push(l), l.__parent = h.__parent, h._icon && (o.removeLayer(h), i || o.addLayer(l))) : h._iconNeedsUpdate = !0, h = h.__parent;
+    delete t.__parent;
+  },
+  _isOrIsParent: (t, e) => {
+    for (; e; ) {
+      if (t === e) return !0;
+      e = e.parentNode;
+    }
+    return !1;
+  },
+  //Override L.Evented.fire
+  fire: function(t, e, i) {
+    if (e && e.propagatedFrom instanceof u.MarkerCluster) {
+      if (e.originalEvent && this._isOrIsParent(
+        e.propagatedFrom._icon,
+        e.originalEvent.relatedTarget
+      ))
+        return;
+      t = `cluster${t}`;
+    }
+    u.FeatureGroup.prototype.fire.call(this, t, e, i);
+  },
+  //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);
+  },
+  //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)
+    });
+  },
+  _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)));
+  },
+  _hideCoverage: function() {
+    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));
+  },
+  _zoomEnd: function() {
+    this._map && (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;
+    }
+  },
+  _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);
+  },
+  //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;
+        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)
+          );
+        h._addChild(l), this._removeFromGridUnclustered(a, e);
+        return;
+      }
+      n[e].addObject(t, o);
+    }
+    this._topClusterLevel._addChild(t), t.__parent = this._topClusterLevel;
+  },
+  /**
+   * Refreshes the icon of all "dirty" visible clusters.
+   * Non-visible "dirty" clusters will be updated when they are added to the map.
+   * @private
+   */
+  _refreshClustersIcons: function() {
+    this._featureGroup.eachLayer((t) => {
+      t instanceof u.MarkerCluster && t._iconNeedsUpdate && t._updateIcon();
+    });
+  },
+  //Enqueue code to fire after the marker expand/contract has happened
+  _enqueue: function(t) {
+    this._queue.push(t), 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;
+  },
+  //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();
+  },
+  //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;
+    return this._checkBoundsMaxLat(this._map.getBounds().pad(1));
+  },
+  /**
+   * Expands the latitude to Infinity (or -Infinity) if the input bounds reach the map projection maximum defined latitude
+   * (in the case of Web/Spherical Mercator, it is 85.0511287798 / see https://en.wikipedia.org/wiki/Web_Mercator#Formulas).
+   * Otherwise, the removeOutsideVisibleBounds option will remove markers beyond that limit, whereas the same markers without
+   * this option (or outside MCG) will have their position floored (ceiled) by the projection and rendered at that limit,
+   * making the user think that MCG "eats" them and never displays them again.
+   * @param bounds L.LatLngBounds
+   * @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;
+  },
+  //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();
+  },
+  /**
+   * Extracts individual (i.e. non-group) layers from a Layer Group.
+   * @param group to extract layers from.
+   * @param output {Array} in which to store the extracted layers.
+   * @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);
+        continue;
+      }
+      e.push(s);
+    }
+    return e;
+  },
+  /**
+   * Implements the singleMarkerMode option.
+   * @param layer Marker to re-style using the Clusters iconCreateFunction.
+   * @returns {L.Icon} The newly created icon.
+   * @private
+   */
+  _overrideMarkerIcon: function(t) {
+    return t.options.icon = this.options.iconCreateFunction({
+      getChildCount: () => 1,
+      getAllChildMarkers: () => [t]
+    }), t.options.icon;
+  }
+});
+u.MarkerClusterGroup.include({
+  _mapBoundsInfinite: new u.LatLngBounds(
+    new u.LatLng(-1 / 0, -1 / 0),
+    new u.LatLng(1 / 0, 1 / 0)
+  )
+});
+u.MarkerClusterGroup.include({
+  _noAnimation: {
+    //Non Animated versions of everything
+    _animationStart: () => {
+    },
+    _animationZoomIn: function(t, e) {
+      this._topClusterLevel._recursivelyRemoveChildrenFromMap(
+        this._currentShownBounds,
+        Math.floor(this._map.getMinZoom()),
+        t
+      ), this._topClusterLevel._recursivelyAddChildrenToMap(
+        null,
+        e,
+        this._getExpandedVisibleBounds()
+      ), this.fire("animationend");
+    },
+    _animationZoomOut: function(t, e) {
+      this._topClusterLevel._recursivelyRemoveChildrenFromMap(
+        this._currentShownBounds,
+        Math.floor(this._map.getMinZoom()),
+        t
+      ), this._topClusterLevel._recursivelyAddChildrenToMap(
+        null,
+        e,
+        this._getExpandedVisibleBounds()
+      ), this.fire("animationend");
+    },
+    _animationAddLayer: function(t, e) {
+      this._animationAddLayerNonAnimated(t, e);
+    }
+  },
+  _withAnimation: {
+    //Animated versions here
+    _animationStart: function() {
+      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(_);
+        }
+      ), 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._ignoreMove = !1, this._enqueue(function() {
+        this._topClusterLevel._recursively(
+          i,
+          t,
+          s,
+          (r) => {
+            n.removeLayer(r), r.clusterShow();
+          }
+        ), this._animationEnd();
+      });
+    },
+    _animationZoomOut: function(t, e) {
+      this._animationZoomOutSingle(
+        this._topClusterLevel,
+        t - 1,
+        e
+      ), this._topClusterLevel._recursivelyAddChildrenToMap(
+        null,
+        e,
+        this._getExpandedVisibleBounds()
+      ), this._topClusterLevel._recursivelyRemoveChildrenFromMap(
+        this._currentShownBounds,
+        Math.floor(this._map.getMinZoom()),
+        t,
+        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
+      )));
+    }
+  },
+  // 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
+    );
+    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
+          );
+        });
+      o._animationEnd();
+    });
+  },
+  _animationEnd: function() {
+    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);
+  }
+});
+u.MarkerCluster = u.Marker.extend({
+  initialize: function(t, e, i, n) {
+    u.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);
+  },
+  //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;
+  },
+  //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;
+    }
+    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;
+  },
+  _updateIcon: function() {
+    this._iconNeedsUpdate = !0, 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();
+  },
+  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);
+  },
+  /**
+   * 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);
+  },
+  /**
+   * Assigns impossible bounding values so that the next extend entirely determines the new bounds.
+   * This method avoids having to trash the previous L.LatLngBounds object and to create a new one, which is much slower for this class.
+   * As long as the bounds are not extended, most other methods would probably fail, as they would with bounds initialized but not extended.
+   * @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);
+  },
+  _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;
+    }
+  },
+  //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);
+  },
+  _recursivelyAnimateChildrenIn: function(t, e, i) {
+    this._recursively(
+      t,
+      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());
+      },
+      (n) => {
+        var s = n._childClusters, o, r;
+        for (o = s.length - 1; o >= 0; o--)
+          r = s[o], r._icon && (r._setPos(e), r.clusterHide());
+      }
+    );
+  },
+  _recursivelyAnimateChildrenInAndAddSelfToMap: function(t, e, i, n) {
+    this._recursively(t, n, e, (s) => {
+      s._recursivelyAnimateChildrenIn(
+        t,
+        s._group._map.latLngToLayerPoint(s.getLatLng()).round(),
+        i
+      ), s._isSingleParent() && i - 1 === n ? (s.clusterShow(), s._recursivelyRemoveChildrenFromMap(
+        t,
+        e,
+        i
+      )) : s.clusterHide(), s._addToMap();
+    });
+  },
+  _recursivelyBecomeVisible: function(t, e) {
+    this._recursively(
+      t,
+      this._group._map.getMinZoom(),
+      e,
+      null,
+      (i) => {
+        i.clusterShow();
+      }
+    );
+  },
+  _recursivelyAddChildrenToMap: function(t, e, i) {
+    this._recursively(
+      i,
+      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));
+          }
+      },
+      (n) => {
+        n._addToMap(t);
+      }
+    );
+  },
+  _recursivelyRestoreChildPositions: function(t) {
+    for (let e = this._markers.length - 1; e >= 0; e--) {
+      const i = this._markers[e];
+      i._backupLatlng && (i.setLatLng(i._backupLatlng), delete i._backupLatlng);
+    }
+    if (t - 1 === this._zoom)
+      for (let e = this._childClusters.length - 1; e >= 0; e--)
+        this._childClusters[e]._restorePosition();
+    else
+      for (let e = this._childClusters.length - 1; e >= 0; e--)
+        this._childClusters[e]._recursivelyRestoreChildPositions(t);
+  },
+  _restorePosition: function() {
+    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;
+    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());
+      },
+      (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());
+      }
+    );
+  },
+  //Run the given functions recursively to this and child clusters
+  // boundsToApplyTo: a L.LatLngBounds representing the bounds of what clusters to recurse in to
+  // zoomLevelToStart: zoom level to start running functions (inclusive)
+  // 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
+        );
+  },
+  //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({
+  clusterHide: function() {
+    return this.options.opacityWhenUnclustered = this.options.opacity || 1, this.setOpacity(0);
+  },
+  clusterShow: function() {
+    var t = this.setOpacity(
+      this.options.opacity || this.options.opacityWhenUnclustered
+    );
+    return delete this.options.opacityWhenUnclustered, t;
+  }
+});
+u.DistanceGrid = function(t) {
+  this._cellSize = t, this._sqCellSize = t * t, 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);
+  },
+  //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);
+    }
+    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;
+  }
+};
+u.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);
+  }
+});
+u.MarkerCluster.include({
+  _2PI: Math.PI * 2,
+  _circleFootSeparation: 25,
+  //related to circumference of circle
+  _circleStartAngle: Math.PI / 6,
+  _spiralFootSeparation: 28,
+  //related to size of spiral (experiment!)
+  _spiralLengthStart: 11,
+  _spiralLengthFactor: 5,
+  _circleSpiralSwitchover: 9,
+  //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);
+    }
+  },
+  unspiderfy: function(t) {
+    this._group._inZoomAnimation || (this._animationUnspiderfy(t), this._group._spiderfied = null);
+  },
+  _generatePointsCircle: function(t, e) {
+    var i = this._group.options.spiderfyDistanceMultiplier * this._circleFootSeparation * (2 + t), n = i / this._2PI, s = this._2PI / t, o = [], r, a;
+    for (o.length = t, r = t - 1; r >= 0; r--)
+      a = this._circleStartAngle + r * s, o[r] = new u.Point(
+        e.x + n * Math.cos(a),
+        e.y + n * Math.sin(a)
+      )._round();
+    return o;
+  },
+  _generatePointsSpiral: function(t, e) {
+    var i = this._group.options.spiderfyDistanceMultiplier, n = i * this._spiralLengthStart, s = i * this._spiralFootSeparation, o = i * this._spiralLengthFactor * this._2PI, r = 0, a = [], h;
+    for (a.length = t, h = t - 1; h >= 0; h--)
+      r += s / n + h * 5e-4, a[h] = new u.Point(
+        e.x + n * Math.cos(r),
+        e.y + n * Math.sin(r)
+      )._round(), n += o / r;
+    return a;
+  },
+  _noanimationUnspiderfy: function() {
+    var t = this._group, e = t._map, i = t._featureGroup, n = this.getAllChildMarkers(), s, o;
+    for (t._ignoreMove = !0, this.setOpacity(1), o = n.length - 1; o >= 0; o--)
+      s = n[o], i.removeLayer(s), s._preSpiderfyLatlng && (s.setLatLng(s._preSpiderfyLatlng), delete s._preSpiderfyLatlng), s.setZIndexOffset && s.setZIndexOffset(0), s._spiderLeg && (e.removeLayer(s._spiderLeg), delete s._spiderLeg);
+    t.fire("unspiderfied", {
+      cluster: this,
+      markers: n
+    }), t._ignoreMove = !1, t._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", {
+      cluster: this,
+      markers: t
+    });
+  },
+  _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(
+      {},
+      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", {
+        cluster: this,
+        markers: t
+      });
+    }, 200);
+  },
+  _animationUnspiderfy: function(t) {
+    var e = this._group, i = e._map, n = e._featureGroup, s = t ? i._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", {
+        cluster: this,
+        markers: o
+      });
+    }, 200);
+  }
+});
+u.MarkerClusterGroup.include({
+  //The MarkerCluster currently spiderfied (if any)
+  _spiderfied: null,
+  unspiderfy: function(...t) {
+    this._unspiderfy.apply(this, t);
+  },
+  _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);
+  },
+  _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();
+  },
+  //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);
+  },
+  _unspiderfyZoomAnim: function(t) {
+    this._map._mapPane.classList.contains("leaflet-touching") || (this._map.off("zoomanim", this._unspiderfyZoomAnim, this), this._unspiderfy(t));
+  },
+  _unspiderfyWrapper: function() {
+    this._unspiderfy();
+  },
+  _unspiderfy: function(t) {
+    this._spiderfied && this._spiderfied.unspiderfy(t);
+  },
+  _noanimationUnspiderfy: function() {
+    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);
+  }
+});
+u.MarkerClusterGroup.include({
+  /**
+   * Updates the icon of all clusters which are parents of the given marker(s).
+   * In singleMarkerMode, also updates the given marker(s) icon.
+   * @param layers L.MarkerClusterGroup|L.LayerGroup|Array(L.Marker)|Map(L.Marker)|
+   * L.MarkerCluster|L.Marker (optional) list of markers (or single marker) whose parent
+   * 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;
+  },
+  /**
+   * 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;
+  },
+  /**
+   * Re-draws the icon of the supplied markers.
+   * To be used in singleMarkerMode only.
+   * @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));
+  }
+});
+u.Marker.include({
+  /**
+   * Updates the given options in the marker's icon and refreshes the marker.
+   * @param options map object of icon options.
+   * @param directlyRefreshClusters boolean (optional) true to trigger
+   * 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;
+  }
+});
+//# sourceMappingURL=cluster.js.map