/* eslint-disable */
let __extends = (this && this.__extends) || (function () {
    let extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b }) ||
        function (d, b) { for (let p in b) if (b.hasOwnProperty(p)) d[p] = b[p] }
    return function (d, b) {
        extendStatics(d, b)
        function __() { this.constructor = d }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __())
    }
})()
export let PruneCluster;
(function (PruneCluster_1) {
    let Point = (function () {
        function Point() {
        }
        return Point
    }())
    PruneCluster_1.Point = Point
    let ClusterObject = (function () {
        function ClusterObject() {
        }
        return ClusterObject
    }())
    PruneCluster_1.ClusterObject = ClusterObject
    let hashCodeCounter = 1
    let maxHashCodeValue = Math.pow(2, 53) - 1
    let Marker = (function (_super) {
        __extends(Marker, _super)
        function Marker(lat, lng, data, category, weight, filtered) {
            if (data === void 0) { data = {} }
            if (weight === void 0) { weight = 1 }
            if (filtered === void 0) { filtered = false }
            let _this = _super.call(this) || this
            _this.data = data
            _this.position = { lat: +lat, lng: +lng }
            _this.weight = weight
            _this.category = category
            _this.filtered = filtered
            _this.hashCode = hashCodeCounter++
            return _this
        }
        Marker.prototype.Move = function (lat, lng) {
            this.position.lat = +lat
            this.position.lng = +lng
        }
        Marker.prototype.SetData = function (data) {
            for (let key in data) {
                this.data[key] = data[key]
            }
        }
        return Marker
    }(ClusterObject))
    PruneCluster_1.Marker = Marker
    let Cluster = (function (_super) {
        __extends(Cluster, _super)
        function Cluster(marker) {
            let _this = _super.call(this) || this
            _this.stats = [0, 0, 0, 0, 0, 0, 0, 0]
            _this.data = {}
            if (!marker) {
                _this.hashCode = 1
                if (Cluster.ENABLE_MARKERS_LIST) {
                    _this._clusterMarkers = []
                }
                return _this
            }
            if (Cluster.ENABLE_MARKERS_LIST) {
                _this._clusterMarkers = [marker]
            }
            _this.lastMarker = marker
            _this.hashCode = 31 + marker.hashCode
            _this.population = 1
            if (marker.category !== undefined) {
                _this.stats[marker.category] = 1
            }
            _this.totalWeight = marker.weight
            _this.position = {
                lat: marker.position.lat,
                lng: marker.position.lng
            }
            _this.averagePosition = {
                lat: marker.position.lat,
                lng: marker.position.lng
            }
            return _this
        }
        Cluster.prototype.AddMarker = function (marker) {
            if (Cluster.ENABLE_MARKERS_LIST) {
                this._clusterMarkers.push(marker)
            }
            let h = this.hashCode
            h = ((h << 5) - h) + marker.hashCode
            if (h >= maxHashCodeValue) {
                this.hashCode = h % maxHashCodeValue
            } else {
                this.hashCode = h
            }
            this.lastMarker = marker
            let weight = marker.weight, currentTotalWeight = this.totalWeight, newWeight = weight + currentTotalWeight
            this.averagePosition.lat =
                (this.averagePosition.lat * currentTotalWeight +
                    marker.position.lat * weight) / newWeight
            this.averagePosition.lng =
                (this.averagePosition.lng * currentTotalWeight +
                    marker.position.lng * weight) / newWeight
            ++this.population
            this.totalWeight = newWeight
            if (marker.category !== undefined) {
                this.stats[marker.category] = (this.stats[marker.category] + 1) || 1
            }
        }
        Cluster.prototype.Reset = function () {
            this.hashCode = 1
            this.lastMarker = undefined
            this.population = 0
            this.totalWeight = 0
            this.stats = [0, 0, 0, 0, 0, 0, 0, 0]
            if (Cluster.ENABLE_MARKERS_LIST) {
                this._clusterMarkers = []
            }
        }
        Cluster.prototype.ComputeBounds = function (cluster) {
            let proj = cluster.Project(this.position.lat, this.position.lng)
            let size = cluster.Size
            let nbX = Math.floor(proj.x / size), nbY = Math.floor(proj.y / size), startX = nbX * size, startY = nbY * size
            let a = cluster.UnProject(startX, startY), b = cluster.UnProject(startX + size, startY + size)
            this.bounds = {
                minLat: b.lat,
                maxLat: a.lat,
                minLng: a.lng,
                maxLng: b.lng
            }
        }
        Cluster.prototype.GetClusterMarkers = function () {
            return this._clusterMarkers
        }
        Cluster.prototype.ApplyCluster = function (newCluster) {
            this.hashCode = this.hashCode * 41 + newCluster.hashCode * 43
            if (this.hashCode > maxHashCodeValue) {
                this.hashCode = this.hashCode = maxHashCodeValue
            }
            let weight = newCluster.totalWeight, currentTotalWeight = this.totalWeight, newWeight = weight + currentTotalWeight
            this.averagePosition.lat =
                (this.averagePosition.lat * currentTotalWeight +
                    newCluster.averagePosition.lat * weight) / newWeight
            this.averagePosition.lng =
                (this.averagePosition.lng * currentTotalWeight +
                    newCluster.averagePosition.lng * weight) / newWeight
            this.population += newCluster.population
            this.totalWeight = newWeight
            this.bounds.minLat = Math.min(this.bounds.minLat, newCluster.bounds.minLat)
            this.bounds.minLng = Math.min(this.bounds.minLng, newCluster.bounds.minLng)
            this.bounds.maxLat = Math.max(this.bounds.maxLat, newCluster.bounds.maxLat)
            this.bounds.maxLng = Math.max(this.bounds.maxLng, newCluster.bounds.maxLng)
            for (let category in newCluster.stats) {
                if (newCluster.stats.hasOwnProperty(category)) {
                    if (this.stats.hasOwnProperty(category)) {
                        this.stats[category] += newCluster.stats[category]
                    } else {
                        this.stats[category] = newCluster.stats[category]
                    }
                }
            }
            if (Cluster.ENABLE_MARKERS_LIST) {
                this._clusterMarkers = this._clusterMarkers.concat(newCluster.GetClusterMarkers())
            }
        }
        Cluster.ENABLE_MARKERS_LIST = false
        return Cluster
    }(ClusterObject))
    PruneCluster_1.Cluster = Cluster
    function checkPositionInsideBounds(a, b) {
        return (a.lat >= b.minLat && a.lat <= b.maxLat) &&
            a.lng >= b.minLng && a.lng <= b.maxLng
    }
    function insertionSort(list) {
        for (let i = 1, j, tmp, tmpLng, length = list.length; i < length; ++i) {
            tmp = list[i]
            tmpLng = tmp.position.lng
            for (j = i - 1; j >= 0 && list[j].position.lng > tmpLng; --j) {
                list[j + 1] = list[j]
            }
            list[j + 1] = tmp
        }
    }
    function shouldUseInsertionSort(total, nbChanges) {
        if (nbChanges > 300) {
            return false
        } else {
            return (nbChanges / total) < 0.2
        }
    }
    let PruneCluster = (function () {
        function PruneCluster() {
            this._markers = []
            this._nbChanges = 0
            this._clusters = []
            this.Size = 166
            this.ViewPadding = 0.2
        }
        PruneCluster.prototype.RegisterMarker = function (marker) {
            if (marker._removeFlag) {
                delete marker._removeFlag
            }
            this._markers.push(marker)
            this._nbChanges += 1
        }
        PruneCluster.prototype.RegisterMarkers = function (markers) {
            let _this = this
            markers.forEach(function (marker) {
                _this.RegisterMarker(marker)
            })
        }
        PruneCluster.prototype._sortMarkers = function () {
            let markers = this._markers, length = markers.length
            if (this._nbChanges && !shouldUseInsertionSort(length, this._nbChanges)) {
                this._markers.sort(function (a, b) { return a.position.lng - b.position.lng })
            } else {
                insertionSort(markers)
            }
            this._nbChanges = 0
        }
        PruneCluster.prototype._sortClusters = function () {
            insertionSort(this._clusters)
        }
        PruneCluster.prototype._indexLowerBoundLng = function (lng) {
            let markers = this._markers, it, step, first = 0, count = markers.length
            while (count > 0) {
                step = Math.floor(count / 2)
                it = first + step
                if (markers[it].position.lng < lng) {
                    first = ++it
                    count -= step + 1
                } else {
                    count = step
                }
            }
            return first
        }
        PruneCluster.prototype._resetClusterViews = function () {
            for (let i = 0, l = this._clusters.length; i < l; ++i) {
                let cluster = this._clusters[i]
                cluster.Reset()
                cluster.ComputeBounds(this)
            }
        }
        PruneCluster.prototype.ProcessView = function (bounds) {
            let heightBuffer = Math.abs(bounds.maxLat - bounds.minLat) * this.ViewPadding, widthBuffer = Math.abs(bounds.maxLng - bounds.minLng) * this.ViewPadding
            let extendedBounds = {
                minLat: bounds.minLat - heightBuffer - heightBuffer,
                maxLat: bounds.maxLat + heightBuffer + heightBuffer,
                minLng: bounds.minLng - widthBuffer - widthBuffer,
                maxLng: bounds.maxLng + widthBuffer + widthBuffer
            }
            this._sortMarkers()
            this._resetClusterViews()
            let firstIndex = this._indexLowerBoundLng(extendedBounds.minLng)
            let markers = this._markers, clusters = this._clusters
            let workingClusterList = clusters.slice(0)
            for (let i = firstIndex, l = markers.length; i < l; ++i) {
                let marker = markers[i], markerPosition = marker.position
                if (markerPosition.lng > extendedBounds.maxLng) {
                    break
                }
                if (markerPosition.lat > extendedBounds.minLat &&
                    markerPosition.lat < extendedBounds.maxLat &&
                    !marker.filtered) {
                    let clusterFound = false, cluster
                    for (let j = 0, ll = workingClusterList.length; j < ll; ++j) {
                        cluster = workingClusterList[j]
                        if (cluster.bounds.maxLng < marker.position.lng) {
                            workingClusterList.splice(j, 1)
                            --j
                            --ll
                            continue
                        }
                        if (checkPositionInsideBounds(markerPosition, cluster.bounds)) {
                            cluster.AddMarker(marker)
                            clusterFound = true
                            break
                        }
                    }
                    if (!clusterFound) {
                        cluster = new Cluster(marker)
                        cluster.ComputeBounds(this)
                        clusters.push(cluster)
                        workingClusterList.push(cluster)
                    }
                }
            }
            let newClustersList = []
            for (i = 0, l = clusters.length; i < l; ++i) {
               let cluster = clusters[i]
                if (cluster.population > 0) {
                    newClustersList.push(cluster)
                }
            }
            this._clusters = newClustersList
            this._sortClusters()
            return this._clusters
        }
        PruneCluster.prototype.RemoveMarkers = function (markers) {
            if (!markers) {
                this._markers = []
                return
            }
            for (let i = 0, l = markers.length; i < l; ++i) {
                markers[i]._removeFlag = true
            }
            let newMarkersList = []
            for (i = 0, l = this._markers.length; i < l; ++i) {
                if (!this._markers[i]._removeFlag) {
                    newMarkersList.push(this._markers[i])
                } else {
                    delete this._markers[i]._removeFlag
                }
            }
            this._markers = newMarkersList
        }
        PruneCluster.prototype.FindMarkersInArea = function (area) {
            let aMinLat = area.minLat, aMaxLat = area.maxLat, aMinLng = area.minLng, aMaxLng = area.maxLng, markers = this._markers, result = []
            let firstIndex = this._indexLowerBoundLng(aMinLng)
            for (let i = firstIndex, l = markers.length; i < l; ++i) {
                let pos = markers[i].position
                if (pos.lng > aMaxLng) {
                    break
                }
                if (pos.lat >= aMinLat && pos.lat <= aMaxLat &&
                    pos.lng >= aMinLng) {
                    result.push(markers[i])
                }
            }
            return result
        }
        PruneCluster.prototype.ComputeBounds = function (markers, withFiltered) {
            if (withFiltered === void 0) { withFiltered = true }
            if (!markers || !markers.length) {
                return null
            }
            let rMinLat = Number.MAX_VALUE, rMaxLat = -Number.MAX_VALUE, rMinLng = Number.MAX_VALUE, rMaxLng = -Number.MAX_VALUE
            for (let i = 0, l = markers.length; i < l; ++i) {
                if (!withFiltered && markers[i].filtered) {
                    continue
                }
                let pos = markers[i].position
                if (pos.lat < rMinLat) { rMinLat = pos.lat }
                if (pos.lat > rMaxLat) { rMaxLat = pos.lat }
                if (pos.lng < rMinLng) { rMinLng = pos.lng }
                if (pos.lng > rMaxLng) { rMaxLng = pos.lng }
            }
            return {
                minLat: rMinLat,
                maxLat: rMaxLat,
                minLng: rMinLng,
                maxLng: rMaxLng
            }
        }
        PruneCluster.prototype.FindMarkersBoundsInArea = function (area) {
            return this.ComputeBounds(this.FindMarkersInArea(area))
        }
        PruneCluster.prototype.ComputeGlobalBounds = function (withFiltered) {
            if (withFiltered === void 0) { withFiltered = true }
            return this.ComputeBounds(this._markers, withFiltered)
        }
        PruneCluster.prototype.GetMarkers = function () {
            return this._markers
        }
        PruneCluster.prototype.GetPopulation = function () {
            return this._markers.length
        }
        PruneCluster.prototype.ResetClusters = function () {
            this._clusters = []
        }
        return PruneCluster
    }())
    PruneCluster_1.PruneCluster = PruneCluster
})(PruneCluster || (PruneCluster = {}))

// let PruneCluster;
// (function (PruneCluster) {
// })(PruneCluster || (PruneCluster = {}));

export let PruneClusterForLeaflet = (L.Layer ? L.Layer : L.Class).extend({
    initialize: function (size, clusterMargin) {
        let _this = this
        if (size === void 0) { size = 120 }
        if (clusterMargin === void 0) { clusterMargin = 20 }
        this.Cluster = new PruneCluster.PruneCluster()
        this.Cluster.Size = size
        this.clusterMargin = Math.min(clusterMargin, size / 4)
        this.Cluster.Project = function (lat, lng) {
            return _this._map.project(new L.LatLng(lat, lng), Math.floor(_this._map.getZoom()))
        }
        this.Cluster.UnProject = function (x, y) {
            return _this._map.unproject(new L.Point(x, y), Math.floor(_this._map.getZoom()))
        }
        this._objectsOnMap = []
        this.spiderfier = new PruneClusterLeafletSpiderfier(this)
        this._hardMove = false
        this._resetIcons = false
        this._removeTimeoutId = 0
        this._markersRemoveListTimeout = []
    },
    RegisterMarker: function (marker) {
        this.Cluster.RegisterMarker(marker)
    },
    RegisterMarkers: function (markers) {
        this.Cluster.RegisterMarkers(markers)
    },
    RemoveMarkers: function (markers) {
        this.Cluster.RemoveMarkers(markers)
    },
    BuildLeafletCluster: function (cluster, position) {
        let _this = this
        let m = new L.Marker(position, {
            icon: this.BuildLeafletClusterIcon(cluster)
        })
        m._leafletClusterBounds = cluster.bounds
        m.on('click', function () {
            let cbounds = m._leafletClusterBounds
            let markersArea = _this.Cluster.FindMarkersInArea(cbounds)
            let b = _this.Cluster.ComputeBounds(markersArea)
            if (b) {
                let bounds = new L.LatLngBounds(new L.LatLng(b.minLat, b.maxLng), new L.LatLng(b.maxLat, b.minLng))
                let zoomLevelBefore = _this._map.getZoom(), zoomLevelAfter = _this._map.getBoundsZoom(bounds, false, new L.Point(20, 20))
                if (zoomLevelAfter === zoomLevelBefore) {
                    let filteredBounds = []
                    for (let i = 0, l = _this._objectsOnMap.length; i < l; ++i) {
                        let o = _this._objectsOnMap[i]
                        if (o.data._leafletMarker !== m) {
                            if (o.bounds.minLat >= cbounds.minLat &&
                                o.bounds.maxLat <= cbounds.maxLat &&
                                o.bounds.minLng >= cbounds.minLng &&
                                o.bounds.maxLng <= cbounds.maxLng) {
                                filteredBounds.push(o.bounds)
                            }
                        }
                    }
                    if (filteredBounds.length > 0) {
                        let newMarkersArea = []
                        let ll = filteredBounds.length
                        for (i = 0, l = markersArea.length; i < l; ++i) {
                            let markerPos = markersArea[i].position
                            let isFiltered = false
                            for (let j = 0; j < ll; ++j) {
                                let currentFilteredBounds = filteredBounds[j]
                                if (markerPos.lat >= currentFilteredBounds.minLat &&
                                    markerPos.lat <= currentFilteredBounds.maxLat &&
                                    markerPos.lng >= currentFilteredBounds.minLng &&
                                    markerPos.lng <= currentFilteredBounds.maxLng) {
                                    isFiltered = true
                                    break
                                }
                            }
                            if (!isFiltered) {
                                newMarkersArea.push(markersArea[i])
                            }
                        }
                        markersArea = newMarkersArea
                    }
                    if (markersArea.length < 200 || zoomLevelAfter >= _this._map.getMaxZoom()) {
                        _this._map.fire('overlappingmarkers', {
                            cluster: _this,
                            markers: markersArea,
                            center: m.getLatLng(),
                            marker: m
                        })
                    } else {
                        zoomLevelAfter++
                    }
                    _this._map.setView(m.getLatLng(), zoomLevelAfter)
                } else {
                    _this._map.fitBounds(bounds)
                }
            }
        })
        return m
    },
    BuildLeafletClusterIcon: function (cluster) {
        let c = 'prunecluster prunecluster-'
        let iconSize = 38
        let maxPopulation = this.Cluster.GetPopulation()
        if (cluster.population < Math.max(10, maxPopulation * 0.01)) {
            c += 'small'
        } else if (cluster.population < Math.max(100, maxPopulation * 0.05)) {
            c += 'medium'
            iconSize = 40
        } else {
            c += 'large'
            iconSize = 44
        }
        return new L.DivIcon({
            html: '<div><span>' + cluster.population + '</span></div>',
            className: c,
            iconSize: L.point(iconSize, iconSize)
        })
    },
    BuildLeafletMarker: function (marker, position) {
        let m = new L.Marker(position)
        this.PrepareLeafletMarker(m, marker.data, marker.category)
        return m
    },
    PrepareLeafletMarker: function (marker, data, category) {
        if (data.icon) {
            if (typeof data.icon === 'function') {
                marker.setIcon(data.icon(data, category))
            } else {
                marker.setIcon(data.icon)
            }
        }
        if (data.popup) {
            let content = typeof data.popup === 'function' ? data.popup(data, category) : data.popup
            if (marker.getPopup()) {
                marker.setPopupContent(content, data.popupOptions)
            } else {
                marker.bindPopup(content, data.popupOptions)
            }
        }
    },
    onAdd: function (map) {
        this._map = map
        map.on('movestart', this._moveStart, this)
        map.on('moveend', this._moveEnd, this)
        map.on('zoomend', this._zoomStart, this)
        map.on('zoomend', this._zoomEnd, this)
        this.ProcessView()
        map.addLayer(this.spiderfier)
    },
    onRemove: function (map) {
        map.off('movestart', this._moveStart, this)
        map.off('moveend', this._moveEnd, this)
        map.off('zoomend', this._zoomStart, this)
        map.off('zoomend', this._zoomEnd, this)
        for (let i = 0, l = this._objectsOnMap.length; i < l; ++i) {
            map.removeLayer(this._objectsOnMap[i].data._leafletMarker)
        }
        this._objectsOnMap = []
        this.Cluster.ResetClusters()
        map.removeLayer(this.spiderfier)
        this._map = null
    },
    _moveStart: function () {
        this._moveInProgress = true
    },
    _moveEnd: function (e) {
        this._moveInProgress = false
        this._hardMove = e.hard
        this.ProcessView()
    },
    _zoomStart: function () {
        this._zoomInProgress = true
    },
    _zoomEnd: function () {
        this._zoomInProgress = false
        this.ProcessView()
    },
    ProcessView: function () {
        let _this = this
        if (!this._map || this._zoomInProgress || this._moveInProgress) {
            return
        }
        let map = this._map, bounds = map.getBounds(), zoom = Math.floor(map.getZoom()), marginRatio = this.clusterMargin / this.Cluster.Size, resetIcons = this._resetIcons
        let southWest = bounds.getSouthWest(), northEast = bounds.getNorthEast()
        let clusters = this.Cluster.ProcessView({
            minLat: southWest.lat,
            minLng: southWest.lng,
            maxLat: northEast.lat,
            maxLng: northEast.lng
        })
        let objectsOnMap = this._objectsOnMap, newObjectsOnMap = [], markersOnMap = new Array(objectsOnMap.length)
        for (let i = 0, l = objectsOnMap.length; i < l; ++i) {
            let marker = objectsOnMap[i].data._leafletMarker
            markersOnMap[i] = marker
            marker._removeFromMap = true
        }
        let clusterCreationList = []
        let clusterCreationListPopOne = []
        let opacityUpdateList = []
        let workingList = []
        for (i = 0, l = clusters.length; i < l; ++i) {
            let icluster = clusters[i], iclusterData = icluster.data
            let latMargin = (icluster.bounds.maxLat - icluster.bounds.minLat) * marginRatio, lngMargin = (icluster.bounds.maxLng - icluster.bounds.minLng) * marginRatio
            for (let j = 0, ll = workingList.length; j < ll; ++j) {
                let c = workingList[j]
                if (c.bounds.maxLng < icluster.bounds.minLng) {
                    workingList.splice(j, 1)
                    --j
                    --ll
                    continue
                }
                let oldMaxLng = c.averagePosition.lng + lngMargin, oldMinLat = c.averagePosition.lat - latMargin, oldMaxLat = c.averagePosition.lat + latMargin, newMinLng = icluster.averagePosition.lng - lngMargin, newMinLat = icluster.averagePosition.lat - latMargin, newMaxLat = icluster.averagePosition.lat + latMargin
                if (oldMaxLng > newMinLng && oldMaxLat > newMinLat && oldMinLat < newMaxLat) {
                    iclusterData._leafletCollision = true
                    c.ApplyCluster(icluster)
                    break
                }
            }
            if (!iclusterData._leafletCollision) {
                workingList.push(icluster)
            }
        }
        clusters.forEach(function (cluster) {
            let m = undefined
            let data = cluster.data
            if (data._leafletCollision) {
                data._leafletCollision = false
                data._leafletOldPopulation = 0
                data._leafletOldHashCode = 0
                return
            }
            let position = new L.LatLng(cluster.averagePosition.lat, cluster.averagePosition.lng)
            let oldMarker = data._leafletMarker
            if (oldMarker) {
                if (cluster.population === 1 && data._leafletOldPopulation === 1 && cluster.hashCode === oldMarker._hashCode) {
                    if (resetIcons || oldMarker._zoomLevel !== zoom || cluster.lastMarker.data.forceIconRedraw) {
                        _this.PrepareLeafletMarker(oldMarker, cluster.lastMarker.data, cluster.lastMarker.category)
                        if (cluster.lastMarker.data.forceIconRedraw) {
                            cluster.lastMarker.data.forceIconRedraw = false
                        }
                    }
                    oldMarker.setLatLng(position)
                    m = oldMarker
                } else if (cluster.population > 1 && data._leafletOldPopulation > 1 && (oldMarker._zoomLevel === zoom ||
                    data._leafletPosition.equals(position))) {
                    oldMarker.setLatLng(position)
                    if (resetIcons || cluster.population != data._leafletOldPopulation ||
                        cluster.hashCode !== data._leafletOldHashCode) {
                        let boundsCopy = {}
                        L.Util.extend(boundsCopy, cluster.bounds)
                        oldMarker._leafletClusterBounds = boundsCopy
                        oldMarker.setIcon(_this.BuildLeafletClusterIcon(cluster))
                    }
                    data._leafletOldPopulation = cluster.population
                    data._leafletOldHashCode = cluster.hashCode
                    m = oldMarker
                }
            }
            if (!m) {
                if (cluster.population === 1) {
                    clusterCreationListPopOne.push(cluster)
                } else {
                    clusterCreationList.push(cluster)
                }
                data._leafletPosition = position
                data._leafletOldPopulation = cluster.population
                data._leafletOldHashCode = cluster.hashCode
            } else {
                m._removeFromMap = false
                newObjectsOnMap.push(cluster)
                m._zoomLevel = zoom
                m._hashCode = cluster.hashCode
                m._population = cluster.population
                data._leafletMarker = m
                data._leafletPosition = position
            }
        })
        clusterCreationList = clusterCreationListPopOne.concat(clusterCreationList)
        for (i = 0, l = objectsOnMap.length; i < l; ++i) {
            let icluster = objectsOnMap[i]
            let idata = icluster.data
            let marker = idata._leafletMarker
            if (idata._leafletMarker._removeFromMap) {
                let remove = true
                if (marker._zoomLevel === zoom) {
                    let pa = icluster.averagePosition
                    let latMargin = (icluster.bounds.maxLat - icluster.bounds.minLat) * marginRatio,
                        lngMargin = (icluster.bounds.maxLng - icluster.bounds.minLng) * marginRatio
                    let ll= clusterCreationList.length
                    for (let j = 0; j < ll; ++j) {
                        let jcluster = clusterCreationList[j], jdata = jcluster.data
                        if (marker._population === 1 && jcluster.population === 1 &&
                            marker._hashCode === jcluster.hashCode) {
                            if (resetIcons || jcluster.lastMarker.data.forceIconRedraw) {
                                this.PrepareLeafletMarker(marker, jcluster.lastMarker.data, jcluster.lastMarker.category)
                                if (jcluster.lastMarker.data.forceIconRedraw) {
                                    jcluster.lastMarker.data.forceIconRedraw = false
                                }
                            }
                            marker.setLatLng(jdata._leafletPosition)
                            remove = false
                        } else {
                            let pb = jcluster.averagePosition
                            let oldMinLng = pa.lng - lngMargin, newMaxLng = pb.lng + lngMargin
                            let oldMaxLng = pa.lng + lngMargin
                            let oldMinLat = pa.lat - latMargin
                            let oldMaxLat = pa.lat + latMargin
                            let newMinLng = pb.lng - lngMargin
                            let newMinLat = pb.lat - latMargin
                            let newMaxLat = pb.lat + latMargin
                            if ((marker._population > 1 && jcluster.population > 1) &&
                                (oldMaxLng > newMinLng && oldMinLng < newMaxLng && oldMaxLat > newMinLat && oldMinLat < newMaxLat)) {
                                marker.setLatLng(jdata._leafletPosition)
                                marker.setIcon(this.BuildLeafletClusterIcon(jcluster))
                                let poisson = {}
                                L.Util.extend(poisson, jcluster.bounds)
                                marker._leafletClusterBounds = poisson
                                jdata._leafletOldPopulation = jcluster.population
                                jdata._leafletOldHashCode = jcluster.hashCode
                                marker._population = jcluster.population
                                remove = false
                            }
                        }
                        if (!remove) {
                            jdata._leafletMarker = marker
                            marker._removeFromMap = false
                            newObjectsOnMap.push(jcluster)
                            clusterCreationList.splice(j, 1)
                            --j
                            --ll
                            break
                        }
                    }
                }
                if (remove) {
                    if (!marker._removeFromMap) { console.error('wtf') }
                }
            }
        }
        for (i = 0, l = clusterCreationList.length; i < l; ++i) {
            let icluster = clusterCreationList[i]
            let idata = icluster.data
            let iposition = idata._leafletPosition
            let creationMarker
            if (icluster.population === 1) {
                creationMarker = this.BuildLeafletMarker(icluster.lastMarker, iposition)
            } else {
                creationMarker = this.BuildLeafletCluster(icluster, iposition)
            }
            creationMarker.addTo(map)
            creationMarker.setOpacity(0)
            opacityUpdateList.push(creationMarker)
            idata._leafletMarker = creationMarker
            creationMarker._zoomLevel = zoom
            creationMarker._hashCode = icluster.hashCode
            creationMarker._population = icluster.population
            newObjectsOnMap.push(icluster)
        }
        window.setTimeout(function () {
            for (i = 0, l = opacityUpdateList.length; i < l; ++i) {
                let m = opacityUpdateList[i]
                if (m._icon) { L.DomUtil.addClass(m._icon, 'prunecluster-anim') }
                if (m._shadow) { L.DomUtil.addClass(m._shadow, 'prunecluster-anim') }
                m.setOpacity(1)
            }
        }, 1)
        if (this._hardMove) {
            for (i = 0, l = markersOnMap.length; i < l; ++i) {
                let marker = markersOnMap[i]
                if (marker._removeFromMap) {
                    map.removeLayer(marker)
                }
            }
        } else {
            if (this._removeTimeoutId !== 0) {
                window.clearTimeout(this._removeTimeoutId)
                for (i = 0, l = this._markersRemoveListTimeout.length; i < l; ++i) {
                    map.removeLayer(this._markersRemoveListTimeout[i])
                }
            }
            let toRemove = []
            for (i = 0, l = markersOnMap.length; i < l; ++i) {
               let marker = markersOnMap[i]
                if (marker._removeFromMap) {
                    marker.setOpacity(0)
                    toRemove.push(marker)
                }
            }
            if (toRemove.length > 0) {
                this._removeTimeoutId = window.setTimeout(function () {
                    for (i = 0, l = toRemove.length; i < l; ++i) {
                        map.removeLayer(toRemove[i])
                    }
                    _this._removeTimeoutId = 0
                }, 300)
            }
            this._markersRemoveListTimeout = toRemove
        }
        this._objectsOnMap = newObjectsOnMap
        this._hardMove = false
        this._resetIcons = false
    },
    FitBounds: function (withFiltered) {
        if (withFiltered === void 0) { withFiltered = true }
        let bounds = this.Cluster.ComputeGlobalBounds(withFiltered)
        if (bounds) {
            this._map.fitBounds(new L.LatLngBounds(new L.LatLng(bounds.minLat, bounds.maxLng), new L.LatLng(bounds.maxLat, bounds.minLng)))
        }
    },
    GetMarkers: function () {
        return this.Cluster.GetMarkers()
    },
    RedrawIcons: function (processView) {
        if (processView === void 0) { processView = true }
        this._resetIcons = true
        if (processView) {
            this.ProcessView()
        }
    }
})
export let PruneClusterLeafletSpiderfier = (L.Layer ? L.Layer : L.Class).extend({
    _2PI: Math.PI * 2,
    _circleFootSeparation: 25,
    _circleStartAngle: Math.PI / 6,
    _spiralFootSeparation: 28,
    _spiralLengthStart: 11,
    _spiralLengthFactor: 5,
    _spiralCountTrigger: 8,
    spiderfyDistanceMultiplier: 1,
    initialize: function (cluster) {
        this._cluster = cluster
        this._currentMarkers = []
        this._multiLines = !!L.multiPolyline
        this._lines = this._multiLines
            ? L.multiPolyline([], { weight: 1.5, color: '#222' })
            : L.polyline([], { weight: 1.5, color: '#222' })
    },
    onAdd: function (map) {
        this._map = map
        this._map.on('overlappingmarkers', this.Spiderfy, this)
        this._map.on('click', this.Unspiderfy, this)
        this._map.on('zoomend', this.Unspiderfy, this)
    },
    Spiderfy: function (data) {
        let _this = this
        if (data.cluster !== this._cluster) {
            return
        }
        this.Unspiderfy()
        let markers = data.markers.filter(function (marker) {
            return !marker.filtered
        })
        this._currentCenter = data.center
        let centerPoint = this._map.latLngToLayerPoint(data.center)
        let points
        if (markers.length >= this._spiralCountTrigger) {
            points = this._generatePointsSpiral(markers.length, centerPoint)
        } else {
            if (this._multiLines) {
                centerPoint.y += 10
            }
            points = this._generatePointsCircle(markers.length, centerPoint)
        }
        let polylines = []
        let leafletMarkers = []
        let projectedPoints = []
        for (let i = 0, l = points.length; i < l; ++i) {
            let pos = this._map.layerPointToLatLng(points[i])
            let m = this._cluster.BuildLeafletMarker(markers[i], data.center)
            m.setZIndexOffset(5000)
            m.setOpacity(0)
            this._currentMarkers.push(m)
            this._map.addLayer(m)
            leafletMarkers.push(m)
            projectedPoints.push(pos)
        }
        window.setTimeout(function () {
            for (i = 0, l = points.length; i < l; ++i) {
                leafletMarkers[i].setLatLng(projectedPoints[i])
                    .setOpacity(1)
            }
            let startTime = +new Date()
            let interval = 42, duration = 290
            let anim = window.setInterval(function () {
                polylines = []
                let now = +new Date()
                let d = now - startTime
                if (d >= duration) {
                    window.clearInterval(anim)
                    let stepRatio = 1.0
                } else {
                    let stepRatio = d / duration
                }
                let center = data.center
                for (i = 0, l = points.length; i < l; ++i) {
                    let p = projectedPoints[i], diffLat = p.lat - center.lat, diffLng = p.lng - center.lng
                    polylines.push([center, new L.LatLng(center.lat + diffLat * stepRatio, center.lng + diffLng * stepRatio)])
                }
                _this._lines.setLatLngs(polylines)
            }, interval)
        }, 1)
        this._lines.setLatLngs(polylines)
        this._map.addLayer(this._lines)
        if (data.marker) {
            this._clusterMarker = data.marker.setOpacity(0.3)
        }
    },
    _generatePointsCircle: function (count, centerPt) {
        let circumference = this.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(Math.round(centerPt.x + legLength * Math.cos(angle)), Math.round(centerPt.y + legLength * Math.sin(angle)))
        }
        return res
    },
    _generatePointsSpiral: function (count, centerPt) {
        let legLength = this.spiderfyDistanceMultiplier * this._spiralLengthStart, separation = this.spiderfyDistanceMultiplier * this._spiralFootSeparation, lengthFactor = this.spiderfyDistanceMultiplier * this._spiralLengthFactor, angle = 0, res = [], i
        res.length = count
        for (i = count - 1; i >= 0; i--) {
            angle += separation / legLength + i * 0.0005
            res[i] = new L.Point(Math.round(centerPt.x + legLength * Math.cos(angle)), Math.round(centerPt.y + legLength * Math.sin(angle)))
            legLength += this._2PI * lengthFactor / angle
        }
        return res
    },
    Unspiderfy: function () {
        let _this = this
        for (let i = 0, l = this._currentMarkers.length; i < l; ++i) {
            this._currentMarkers[i].setLatLng(this._currentCenter).setOpacity(0)
        }
        let markers = this._currentMarkers
        window.setTimeout(function () {
            for (i = 0, l = markers.length; i < l; ++i) {
                _this._map.removeLayer(markers[i])
            }
        }, 300)
        this._currentMarkers = []
        this._map.removeLayer(this._lines)
        if (this._clusterMarker) {
            this._clusterMarker.setOpacity(1)
        }
    },
    onRemove: function (map) {
        this.Unspiderfy()
        map.off('overlappingmarkers', this.Spiderfy, this)
        map.off('click', this.Unspiderfy, this)
        map.off('zoomend', this.Unspiderfy, this)
    }
})