{"version":3,"file":"shared/chunks/6121.b8b2ba8b8584f5d184f3.js","mappings":"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","sources":["webpack://dsposal.web/./node_modules/kdbush/src/sort.js","webpack://dsposal.web/./node_modules/kdbush/src/within.js","webpack://dsposal.web/./node_modules/kdbush/src/index.js","webpack://dsposal.web/./node_modules/kdbush/src/range.js","webpack://dsposal.web/./node_modules/supercluster/index.js","webpack://dsposal.web/./node_modules/@googlemaps/markerclusterer/dist/index.esm.js","webpack://dsposal.web/./node_modules/core-js/modules/es.array.reverse.js","webpack://dsposal.web/./node_modules/core-js/modules/es.json.to-string-tag.js","webpack://dsposal.web/./node_modules/core-js/modules/es.math.to-string-tag.js","webpack://dsposal.web/./node_modules/core-js/modules/es.object.get-prototype-of.js","webpack://dsposal.web/./node_modules/core-js/modules/es.symbol.async-iterator.js","webpack://dsposal.web/./node_modules/core-js/modules/es.symbol.iterator.js","webpack://dsposal.web/./node_modules/core-js/modules/es.symbol.to-string-tag.js","webpack://dsposal.web/./node_modules/density-clustering/lib/DBSCAN.js","webpack://dsposal.web/./node_modules/density-clustering/lib/KMEANS.js","webpack://dsposal.web/./node_modules/density-clustering/lib/OPTICS.js","webpack://dsposal.web/./node_modules/density-clustering/lib/PriorityQueue.js","webpack://dsposal.web/./node_modules/density-clustering/lib/index.js","webpack://dsposal.web/./node_modules/fast-deep-equal/es6/index.js","webpack://dsposal.web/./node_modules/skmeans/dist/node/distance.js","webpack://dsposal.web/./node_modules/skmeans/dist/node/kinit.js","webpack://dsposal.web/./node_modules/skmeans/dist/node/main.js"],"sourcesContent":["\nexport default function sortKD(ids, coords, nodeSize, left, right, depth) {\n    if (right - left <= nodeSize) return;\n\n    const m = (left + right) >> 1;\n\n    select(ids, coords, m, left, right, depth % 2);\n\n    sortKD(ids, coords, nodeSize, left, m - 1, depth + 1);\n    sortKD(ids, coords, nodeSize, m + 1, right, depth + 1);\n}\n\nfunction select(ids, coords, k, left, right, inc) {\n\n    while (right > left) {\n        if (right - left > 600) {\n            const n = right - left + 1;\n            const m = k - left + 1;\n            const z = Math.log(n);\n            const s = 0.5 * Math.exp(2 * z / 3);\n            const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);\n            const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));\n            const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));\n            select(ids, coords, k, newLeft, newRight, inc);\n        }\n\n        const t = coords[2 * k + inc];\n        let i = left;\n        let j = right;\n\n        swapItem(ids, coords, left, k);\n        if (coords[2 * right + inc] > t) swapItem(ids, coords, left, right);\n\n        while (i < j) {\n            swapItem(ids, coords, i, j);\n            i++;\n            j--;\n            while (coords[2 * i + inc] < t) i++;\n            while (coords[2 * j + inc] > t) j--;\n        }\n\n        if (coords[2 * left + inc] === t) swapItem(ids, coords, left, j);\n        else {\n            j++;\n            swapItem(ids, coords, j, right);\n        }\n\n        if (j <= k) left = j + 1;\n        if (k <= j) right = j - 1;\n    }\n}\n\nfunction swapItem(ids, coords, i, j) {\n    swap(ids, i, j);\n    swap(coords, 2 * i, 2 * j);\n    swap(coords, 2 * i + 1, 2 * j + 1);\n}\n\nfunction swap(arr, i, j) {\n    const tmp = arr[i];\n    arr[i] = arr[j];\n    arr[j] = tmp;\n}\n","\nexport default function within(ids, coords, qx, qy, r, nodeSize) {\n    const stack = [0, ids.length - 1, 0];\n    const result = [];\n    const r2 = r * r;\n\n    while (stack.length) {\n        const axis = stack.pop();\n        const right = stack.pop();\n        const left = stack.pop();\n\n        if (right - left <= nodeSize) {\n            for (let i = left; i <= right; i++) {\n                if (sqDist(coords[2 * i], coords[2 * i + 1], qx, qy) <= r2) result.push(ids[i]);\n            }\n            continue;\n        }\n\n        const m = Math.floor((left + right) / 2);\n\n        const x = coords[2 * m];\n        const y = coords[2 * m + 1];\n\n        if (sqDist(x, y, qx, qy) <= r2) result.push(ids[m]);\n\n        const nextAxis = (axis + 1) % 2;\n\n        if (axis === 0 ? qx - r <= x : qy - r <= y) {\n            stack.push(left);\n            stack.push(m - 1);\n            stack.push(nextAxis);\n        }\n        if (axis === 0 ? qx + r >= x : qy + r >= y) {\n            stack.push(m + 1);\n            stack.push(right);\n            stack.push(nextAxis);\n        }\n    }\n\n    return result;\n}\n\nfunction sqDist(ax, ay, bx, by) {\n    const dx = ax - bx;\n    const dy = ay - by;\n    return dx * dx + dy * dy;\n}\n","\nimport sort from './sort';\nimport range from './range';\nimport within from './within';\n\nconst defaultGetX = p => p[0];\nconst defaultGetY = p => p[1];\n\nexport default class KDBush {\n    constructor(points, getX = defaultGetX, getY = defaultGetY, nodeSize = 64, ArrayType = Float64Array) {\n        this.nodeSize = nodeSize;\n        this.points = points;\n\n        const IndexArrayType = points.length < 65536 ? Uint16Array : Uint32Array;\n\n        const ids = this.ids = new IndexArrayType(points.length);\n        const coords = this.coords = new ArrayType(points.length * 2);\n\n        for (let i = 0; i < points.length; i++) {\n            ids[i] = i;\n            coords[2 * i] = getX(points[i]);\n            coords[2 * i + 1] = getY(points[i]);\n        }\n\n        sort(ids, coords, nodeSize, 0, ids.length - 1, 0);\n    }\n\n    range(minX, minY, maxX, maxY) {\n        return range(this.ids, this.coords, minX, minY, maxX, maxY, this.nodeSize);\n    }\n\n    within(x, y, r) {\n        return within(this.ids, this.coords, x, y, r, this.nodeSize);\n    }\n}\n","\nexport default function range(ids, coords, minX, minY, maxX, maxY, nodeSize) {\n    const stack = [0, ids.length - 1, 0];\n    const result = [];\n    let x, y;\n\n    while (stack.length) {\n        const axis = stack.pop();\n        const right = stack.pop();\n        const left = stack.pop();\n\n        if (right - left <= nodeSize) {\n            for (let i = left; i <= right; i++) {\n                x = coords[2 * i];\n                y = coords[2 * i + 1];\n                if (x >= minX && x <= maxX && y >= minY && y <= maxY) result.push(ids[i]);\n            }\n            continue;\n        }\n\n        const m = Math.floor((left + right) / 2);\n\n        x = coords[2 * m];\n        y = coords[2 * m + 1];\n\n        if (x >= minX && x <= maxX && y >= minY && y <= maxY) result.push(ids[m]);\n\n        const nextAxis = (axis + 1) % 2;\n\n        if (axis === 0 ? minX <= x : minY <= y) {\n            stack.push(left);\n            stack.push(m - 1);\n            stack.push(nextAxis);\n        }\n        if (axis === 0 ? maxX >= x : maxY >= y) {\n            stack.push(m + 1);\n            stack.push(right);\n            stack.push(nextAxis);\n        }\n    }\n\n    return result;\n}\n","\nimport KDBush from 'kdbush';\n\nconst defaultOptions = {\n    minZoom: 0,   // min zoom to generate clusters on\n    maxZoom: 16,  // max zoom level to cluster the points on\n    minPoints: 2, // minimum points to form a cluster\n    radius: 40,   // cluster radius in pixels\n    extent: 512,  // tile extent (radius is calculated relative to it)\n    nodeSize: 64, // size of the KD-tree leaf node, affects performance\n    log: false,   // whether to log timing info\n\n    // whether to generate numeric ids for input features (in vector tiles)\n    generateId: false,\n\n    // a reduce function for calculating custom cluster properties\n    reduce: null, // (accumulated, props) => { accumulated.sum += props.sum; }\n\n    // properties to use for individual points when running the reducer\n    map: props => props // props => ({sum: props.my_value})\n};\n\nconst fround = Math.fround || (tmp => ((x) => { tmp[0] = +x; return tmp[0]; }))(new Float32Array(1));\n\nexport default class Supercluster {\n    constructor(options) {\n        this.options = extend(Object.create(defaultOptions), options);\n        this.trees = new Array(this.options.maxZoom + 1);\n    }\n\n    load(points) {\n        const {log, minZoom, maxZoom, nodeSize} = this.options;\n\n        if (log) console.time('total time');\n\n        const timerId = `prepare ${  points.length  } points`;\n        if (log) console.time(timerId);\n\n        this.points = points;\n\n        // generate a cluster object for each point and index input points into a KD-tree\n        let clusters = [];\n        for (let i = 0; i < points.length; i++) {\n            if (!points[i].geometry) continue;\n            clusters.push(createPointCluster(points[i], i));\n        }\n        this.trees[maxZoom + 1] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);\n\n        if (log) console.timeEnd(timerId);\n\n        // cluster points on max zoom, then cluster the results on previous zoom, etc.;\n        // results in a cluster hierarchy across zoom levels\n        for (let z = maxZoom; z >= minZoom; z--) {\n            const now = +Date.now();\n\n            // create a new set of clusters for the zoom and index them with a KD-tree\n            clusters = this._cluster(clusters, z);\n            this.trees[z] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);\n\n            if (log) console.log('z%d: %d clusters in %dms', z, clusters.length, +Date.now() - now);\n        }\n\n        if (log) console.timeEnd('total time');\n\n        return this;\n    }\n\n    getClusters(bbox, zoom) {\n        let minLng = ((bbox[0] + 180) % 360 + 360) % 360 - 180;\n        const minLat = Math.max(-90, Math.min(90, bbox[1]));\n        let maxLng = bbox[2] === 180 ? 180 : ((bbox[2] + 180) % 360 + 360) % 360 - 180;\n        const maxLat = Math.max(-90, Math.min(90, bbox[3]));\n\n        if (bbox[2] - bbox[0] >= 360) {\n            minLng = -180;\n            maxLng = 180;\n        } else if (minLng > maxLng) {\n            const easternHem = this.getClusters([minLng, minLat, 180, maxLat], zoom);\n            const westernHem = this.getClusters([-180, minLat, maxLng, maxLat], zoom);\n            return easternHem.concat(westernHem);\n        }\n\n        const tree = this.trees[this._limitZoom(zoom)];\n        const ids = tree.range(lngX(minLng), latY(maxLat), lngX(maxLng), latY(minLat));\n        const clusters = [];\n        for (const id of ids) {\n            const c = tree.points[id];\n            clusters.push(c.numPoints ? getClusterJSON(c) : this.points[c.index]);\n        }\n        return clusters;\n    }\n\n    getChildren(clusterId) {\n        const originId = this._getOriginId(clusterId);\n        const originZoom = this._getOriginZoom(clusterId);\n        const errorMsg = 'No cluster with the specified id.';\n\n        const index = this.trees[originZoom];\n        if (!index) throw new Error(errorMsg);\n\n        const origin = index.points[originId];\n        if (!origin) throw new Error(errorMsg);\n\n        const r = this.options.radius / (this.options.extent * Math.pow(2, originZoom - 1));\n        const ids = index.within(origin.x, origin.y, r);\n        const children = [];\n        for (const id of ids) {\n            const c = index.points[id];\n            if (c.parentId === clusterId) {\n                children.push(c.numPoints ? getClusterJSON(c) : this.points[c.index]);\n            }\n        }\n\n        if (children.length === 0) throw new Error(errorMsg);\n\n        return children;\n    }\n\n    getLeaves(clusterId, limit, offset) {\n        limit = limit || 10;\n        offset = offset || 0;\n\n        const leaves = [];\n        this._appendLeaves(leaves, clusterId, limit, offset, 0);\n\n        return leaves;\n    }\n\n    getTile(z, x, y) {\n        const tree = this.trees[this._limitZoom(z)];\n        const z2 = Math.pow(2, z);\n        const {extent, radius} = this.options;\n        const p = radius / extent;\n        const top = (y - p) / z2;\n        const bottom = (y + 1 + p) / z2;\n\n        const tile = {\n            features: []\n        };\n\n        this._addTileFeatures(\n            tree.range((x - p) / z2, top, (x + 1 + p) / z2, bottom),\n            tree.points, x, y, z2, tile);\n\n        if (x === 0) {\n            this._addTileFeatures(\n                tree.range(1 - p / z2, top, 1, bottom),\n                tree.points, z2, y, z2, tile);\n        }\n        if (x === z2 - 1) {\n            this._addTileFeatures(\n                tree.range(0, top, p / z2, bottom),\n                tree.points, -1, y, z2, tile);\n        }\n\n        return tile.features.length ? tile : null;\n    }\n\n    getClusterExpansionZoom(clusterId) {\n        let expansionZoom = this._getOriginZoom(clusterId) - 1;\n        while (expansionZoom <= this.options.maxZoom) {\n            const children = this.getChildren(clusterId);\n            expansionZoom++;\n            if (children.length !== 1) break;\n            clusterId = children[0].properties.cluster_id;\n        }\n        return expansionZoom;\n    }\n\n    _appendLeaves(result, clusterId, limit, offset, skipped) {\n        const children = this.getChildren(clusterId);\n\n        for (const child of children) {\n            const props = child.properties;\n\n            if (props && props.cluster) {\n                if (skipped + props.point_count <= offset) {\n                    // skip the whole cluster\n                    skipped += props.point_count;\n                } else {\n                    // enter the cluster\n                    skipped = this._appendLeaves(result, props.cluster_id, limit, offset, skipped);\n                    // exit the cluster\n                }\n            } else if (skipped < offset) {\n                // skip a single point\n                skipped++;\n            } else {\n                // add a single point\n                result.push(child);\n            }\n            if (result.length === limit) break;\n        }\n\n        return skipped;\n    }\n\n    _addTileFeatures(ids, points, x, y, z2, tile) {\n        for (const i of ids) {\n            const c = points[i];\n            const isCluster = c.numPoints;\n\n            let tags, px, py;\n            if (isCluster) {\n                tags = getClusterProperties(c);\n                px = c.x;\n                py = c.y;\n            } else {\n                const p = this.points[c.index];\n                tags = p.properties;\n                px = lngX(p.geometry.coordinates[0]);\n                py = latY(p.geometry.coordinates[1]);\n            }\n\n            const f = {\n                type: 1,\n                geometry: [[\n                    Math.round(this.options.extent * (px * z2 - x)),\n                    Math.round(this.options.extent * (py * z2 - y))\n                ]],\n                tags\n            };\n\n            // assign id\n            let id;\n            if (isCluster) {\n                id = c.id;\n            } else if (this.options.generateId) {\n                // optionally generate id\n                id = c.index;\n            } else if (this.points[c.index].id) {\n                // keep id if already assigned\n                id = this.points[c.index].id;\n            }\n\n            if (id !== undefined) f.id = id;\n\n            tile.features.push(f);\n        }\n    }\n\n    _limitZoom(z) {\n        return Math.max(this.options.minZoom, Math.min(Math.floor(+z), this.options.maxZoom + 1));\n    }\n\n    _cluster(points, zoom) {\n        const clusters = [];\n        const {radius, extent, reduce, minPoints} = this.options;\n        const r = radius / (extent * Math.pow(2, zoom));\n\n        // loop through each point\n        for (let i = 0; i < points.length; i++) {\n            const p = points[i];\n            // if we've already visited the point at this zoom level, skip it\n            if (p.zoom <= zoom) continue;\n            p.zoom = zoom;\n\n            // find all nearby points\n            const tree = this.trees[zoom + 1];\n            const neighborIds = tree.within(p.x, p.y, r);\n\n            const numPointsOrigin = p.numPoints || 1;\n            let numPoints = numPointsOrigin;\n\n            // count the number of points in a potential cluster\n            for (const neighborId of neighborIds) {\n                const b = tree.points[neighborId];\n                // filter out neighbors that are already processed\n                if (b.zoom > zoom) numPoints += b.numPoints || 1;\n            }\n\n            // if there were neighbors to merge, and there are enough points to form a cluster\n            if (numPoints > numPointsOrigin && numPoints >= minPoints) {\n                let wx = p.x * numPointsOrigin;\n                let wy = p.y * numPointsOrigin;\n\n                let clusterProperties = reduce && numPointsOrigin > 1 ? this._map(p, true) : null;\n\n                // encode both zoom and point index on which the cluster originated -- offset by total length of features\n                const id = (i << 5) + (zoom + 1) + this.points.length;\n\n                for (const neighborId of neighborIds) {\n                    const b = tree.points[neighborId];\n\n                    if (b.zoom <= zoom) continue;\n                    b.zoom = zoom; // save the zoom (so it doesn't get processed twice)\n\n                    const numPoints2 = b.numPoints || 1;\n                    wx += b.x * numPoints2; // accumulate coordinates for calculating weighted center\n                    wy += b.y * numPoints2;\n\n                    b.parentId = id;\n\n                    if (reduce) {\n                        if (!clusterProperties) clusterProperties = this._map(p, true);\n                        reduce(clusterProperties, this._map(b));\n                    }\n                }\n\n                p.parentId = id;\n                clusters.push(createCluster(wx / numPoints, wy / numPoints, id, numPoints, clusterProperties));\n\n            } else { // left points as unclustered\n                clusters.push(p);\n\n                if (numPoints > 1) {\n                    for (const neighborId of neighborIds) {\n                        const b = tree.points[neighborId];\n                        if (b.zoom <= zoom) continue;\n                        b.zoom = zoom;\n                        clusters.push(b);\n                    }\n                }\n            }\n        }\n\n        return clusters;\n    }\n\n    // get index of the point from which the cluster originated\n    _getOriginId(clusterId) {\n        return (clusterId - this.points.length) >> 5;\n    }\n\n    // get zoom of the point from which the cluster originated\n    _getOriginZoom(clusterId) {\n        return (clusterId - this.points.length) % 32;\n    }\n\n    _map(point, clone) {\n        if (point.numPoints) {\n            return clone ? extend({}, point.properties) : point.properties;\n        }\n        const original = this.points[point.index].properties;\n        const result = this.options.map(original);\n        return clone && result === original ? extend({}, result) : result;\n    }\n}\n\nfunction createCluster(x, y, id, numPoints, properties) {\n    return {\n        x: fround(x), // weighted cluster center; round for consistency with Float32Array index\n        y: fround(y),\n        zoom: Infinity, // the last zoom the cluster was processed at\n        id, // encodes index of the first child of the cluster and its zoom level\n        parentId: -1, // parent cluster id\n        numPoints,\n        properties\n    };\n}\n\nfunction createPointCluster(p, id) {\n    const [x, y] = p.geometry.coordinates;\n    return {\n        x: fround(lngX(x)), // projected point coordinates\n        y: fround(latY(y)),\n        zoom: Infinity, // the last zoom the point was processed at\n        index: id, // index of the source feature in the original input array,\n        parentId: -1 // parent cluster id\n    };\n}\n\nfunction getClusterJSON(cluster) {\n    return {\n        type: 'Feature',\n        id: cluster.id,\n        properties: getClusterProperties(cluster),\n        geometry: {\n            type: 'Point',\n            coordinates: [xLng(cluster.x), yLat(cluster.y)]\n        }\n    };\n}\n\nfunction getClusterProperties(cluster) {\n    const count = cluster.numPoints;\n    const abbrev =\n        count >= 10000 ? `${Math.round(count / 1000)  }k` :\n        count >= 1000 ? `${Math.round(count / 100) / 10  }k` : count;\n    return extend(extend({}, cluster.properties), {\n        cluster: true,\n        cluster_id: cluster.id,\n        point_count: count,\n        point_count_abbreviated: abbrev\n    });\n}\n\n// longitude/latitude to spherical mercator in [0..1] range\nfunction lngX(lng) {\n    return lng / 360 + 0.5;\n}\nfunction latY(lat) {\n    const sin = Math.sin(lat * Math.PI / 180);\n    const y = (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI);\n    return y < 0 ? 0 : y > 1 ? 1 : y;\n}\n\n// spherical mercator to longitude/latitude\nfunction xLng(x) {\n    return (x - 0.5) * 360;\n}\nfunction yLat(y) {\n    const y2 = (180 - y * 360) * Math.PI / 180;\n    return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;\n}\n\nfunction extend(dest, src) {\n    for (const id in src) dest[id] = src[id];\n    return dest;\n}\n\nfunction getX(p) {\n    return p.x;\n}\nfunction getY(p) {\n    return p.y;\n}\n","import { featureCollection, point } from '@turf/helpers';\nimport clustersKmeans from '@turf/clusters-kmeans';\nimport clustersDbscan from '@turf/clusters-dbscan';\nimport SuperCluster from 'supercluster';\nimport equal from 'fast-deep-equal/es6';\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n\r\nfunction __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nclass Cluster {\n    constructor({ markers, position }) {\n        this.markers = markers;\n        if (position) {\n            if (position instanceof google.maps.LatLng) {\n                this._position = position;\n            }\n            else {\n                this._position = new google.maps.LatLng(position);\n            }\n        }\n    }\n    get bounds() {\n        if (this.markers.length === 0 && !this._position) {\n            return undefined;\n        }\n        return this.markers.reduce((bounds, marker) => {\n            return bounds.extend(marker.getPosition());\n        }, new google.maps.LatLngBounds(this._position, this._position));\n    }\n    get position() {\n        return this._position || this.bounds.getCenter();\n    }\n    /**\n     * Get the count of **visible** markers.\n     */\n    get count() {\n        return this.markers.filter((m) => m.getVisible())\n            .length;\n    }\n    /**\n     * Add a marker to the cluster.\n     */\n    push(marker) {\n        this.markers.push(marker);\n    }\n    /**\n     * Cleanup references and remove marker from map.\n     */\n    delete() {\n        if (this.marker) {\n            this.marker.setMap(null);\n            delete this.marker;\n        }\n        this.markers.length = 0;\n    }\n}\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst filterMarkersToPaddedViewport = (map, mapCanvasProjection, markers, viewportPadding) => {\n    const extendedMapBounds = extendBoundsToPaddedViewport(map.getBounds(), mapCanvasProjection, viewportPadding);\n    return markers.filter((marker) => extendedMapBounds.contains(marker.getPosition()));\n};\n/**\n * Extends a bounds by a number of pixels in each direction.\n */\nconst extendBoundsToPaddedViewport = (bounds, projection, pixels) => {\n    const { northEast, southWest } = latLngBoundsToPixelBounds(bounds, projection);\n    const extendedPixelBounds = extendPixelBounds({ northEast, southWest }, pixels);\n    return pixelBoundsToLatLngBounds(extendedPixelBounds, projection);\n};\n/**\n * @hidden\n */\nconst distanceBetweenPoints = (p1, p2) => {\n    const R = 6371; // Radius of the Earth in km\n    const dLat = ((p2.lat - p1.lat) * Math.PI) / 180;\n    const dLon = ((p2.lng - p1.lng) * Math.PI) / 180;\n    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +\n        Math.cos((p1.lat * Math.PI) / 180) *\n            Math.cos((p2.lat * Math.PI) / 180) *\n            Math.sin(dLon / 2) *\n            Math.sin(dLon / 2);\n    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n    return R * c;\n};\n/**\n * @hidden\n */\nconst latLngBoundsToPixelBounds = (bounds, projection) => {\n    return {\n        northEast: projection.fromLatLngToDivPixel(bounds.getNorthEast()),\n        southWest: projection.fromLatLngToDivPixel(bounds.getSouthWest()),\n    };\n};\n/**\n * @hidden\n */\nconst extendPixelBounds = ({ northEast, southWest }, pixels) => {\n    northEast.x += pixels;\n    northEast.y -= pixels;\n    southWest.x -= pixels;\n    southWest.y += pixels;\n    return { northEast, southWest };\n};\n/**\n * @hidden\n */\nconst pixelBoundsToLatLngBounds = ({ northEast, southWest }, projection) => {\n    const bounds = new google.maps.LatLngBounds();\n    bounds.extend(projection.fromDivPixelToLatLng(northEast));\n    bounds.extend(projection.fromDivPixelToLatLng(southWest));\n    return bounds;\n};\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @hidden\n */\nclass AbstractAlgorithm {\n    constructor({ maxZoom = 16 }) {\n        this.maxZoom = maxZoom;\n    }\n    /**\n     * Helper function to bypass clustering based upon some map state such as\n     * zoom, number of markers, etc.\n     *\n     * ```typescript\n     *  cluster({markers, map}: AlgorithmInput): Cluster[] {\n     *    if (shouldBypassClustering(map)) {\n     *      return this.noop({markers, map})\n     *    }\n     * }\n     * ```\n     */\n    noop({ markers }) {\n        return noop(markers);\n    }\n}\n/**\n * Abstract viewport algorithm proves a class to filter markers by a padded\n * viewport. This is a common optimization.\n *\n * @hidden\n */\nclass AbstractViewportAlgorithm extends AbstractAlgorithm {\n    constructor(_a) {\n        var { viewportPadding = 60 } = _a, options = __rest(_a, [\"viewportPadding\"]);\n        super(options);\n        this.viewportPadding = 60;\n        this.viewportPadding = viewportPadding;\n    }\n    calculate({ markers, map, mapCanvasProjection, }) {\n        if (map.getZoom() >= this.maxZoom) {\n            return {\n                clusters: this.noop({\n                    markers,\n                    map,\n                    mapCanvasProjection,\n                }),\n                changed: false,\n            };\n        }\n        return {\n            clusters: this.cluster({\n                markers: filterMarkersToPaddedViewport(map, mapCanvasProjection, markers, this.viewportPadding),\n                map,\n                mapCanvasProjection,\n            }),\n        };\n    }\n}\n/**\n * @hidden\n */\nconst noop = (markers) => {\n    const clusters = markers.map((marker) => new Cluster({\n        position: marker.getPosition(),\n        markers: [marker],\n    }));\n    return clusters;\n};\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * The default Grid algorithm historically used in Google Maps marker\n * clustering.\n *\n * The Grid algorithm does not implement caching and markers may flash as the\n * viewport changes. Instead use {@link SuperClusterAlgorithm}.\n */\nclass GridAlgorithm extends AbstractViewportAlgorithm {\n    constructor(_a) {\n        var { maxDistance = 40000, gridSize = 40 } = _a, options = __rest(_a, [\"maxDistance\", \"gridSize\"]);\n        super(options);\n        this.clusters = [];\n        this.maxDistance = maxDistance;\n        this.gridSize = gridSize;\n    }\n    cluster({ markers, map, mapCanvasProjection, }) {\n        this.clusters = [];\n        markers.forEach((marker) => {\n            this.addToClosestCluster(marker, map, mapCanvasProjection);\n        });\n        return this.clusters;\n    }\n    addToClosestCluster(marker, map, projection) {\n        let maxDistance = this.maxDistance; // Some large number\n        let cluster = null;\n        for (let i = 0; i < this.clusters.length; i++) {\n            const candidate = this.clusters[i];\n            const distance = distanceBetweenPoints(candidate.bounds.getCenter().toJSON(), marker.getPosition().toJSON());\n            if (distance < maxDistance) {\n                maxDistance = distance;\n                cluster = candidate;\n            }\n        }\n        if (cluster &&\n            extendBoundsToPaddedViewport(cluster.bounds, projection, this.gridSize).contains(marker.getPosition())) {\n            cluster.push(marker);\n        }\n        else {\n            const cluster = new Cluster({ markers: [marker] });\n            this.clusters.push(cluster);\n        }\n    }\n}\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Noop algorithm does not generate any clusters or filter markers by the an extended viewport.\n */\nclass NoopAlgorithm extends AbstractAlgorithm {\n    constructor(_a) {\n        var options = __rest(_a, []);\n        super(options);\n    }\n    calculate({ markers, map, mapCanvasProjection, }) {\n        return {\n            clusters: this.cluster({ markers, map, mapCanvasProjection }),\n            changed: false,\n        };\n    }\n    cluster(input) {\n        return this.noop(input);\n    }\n}\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Experimental algorithm using Kmeans.\n *\n * The Grid algorithm does not implement caching and markers may flash as the\n * viewport changes. Instead use {@link SuperClusterAlgorithm}.\n *\n * @see https://www.npmjs.com/package/@turf/clusters-kmeans\n */\nclass KmeansAlgorithm extends AbstractViewportAlgorithm {\n    constructor(_a) {\n        var { numberOfClusters } = _a, options = __rest(_a, [\"numberOfClusters\"]);\n        super(options);\n        this.numberOfClusters = numberOfClusters;\n    }\n    cluster({ markers, map }) {\n        const clusters = [];\n        if (markers.length === 0) {\n            return clusters;\n        }\n        const points = featureCollection(markers.map((marker) => {\n            return point([marker.getPosition().lng(), marker.getPosition().lat()]);\n        }));\n        let numberOfClusters;\n        if (this.numberOfClusters instanceof Function) {\n            numberOfClusters = this.numberOfClusters(markers.length, map.getZoom());\n        }\n        else {\n            numberOfClusters = this.numberOfClusters;\n        }\n        clustersKmeans(points, { numberOfClusters }).features.forEach((point, i) => {\n            if (!clusters[point.properties.cluster]) {\n                clusters[point.properties.cluster] = new Cluster({\n                    position: {\n                        lng: point.properties.centroid[0],\n                        lat: point.properties.centroid[1],\n                    },\n                    markers: [],\n                });\n            }\n            clusters[point.properties.cluster].push(markers[i]);\n        });\n        return clusters;\n    }\n}\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst DEFAULT_INTERNAL_DBSCAN_OPTION = {\n    units: \"kilometers\",\n    mutate: false,\n    minPoints: 1,\n};\n/**\n *\n * **This algorithm is not yet ready for use!**\n *\n * Experimental algorithm using DBScan.\n *\n * The Grid algorithm does not implement caching and markers may flash as the\n * viewport changes. Instead use {@link SuperClusterAlgorithm}.\n *\n * @see https://www.npmjs.com/package/@turf/clusters-dbscan\n */\nclass DBScanAlgorithm extends AbstractViewportAlgorithm {\n    constructor(_a) {\n        var { maxDistance = 200, minPoints = DEFAULT_INTERNAL_DBSCAN_OPTION.minPoints } = _a, options = __rest(_a, [\"maxDistance\", \"minPoints\"]);\n        super(options);\n        this.maxDistance = maxDistance;\n        this.options = Object.assign(Object.assign({}, DEFAULT_INTERNAL_DBSCAN_OPTION), { minPoints });\n    }\n    cluster({ markers, mapCanvasProjection, }) {\n        const points = featureCollection(markers.map((marker) => {\n            const projectedPoint = mapCanvasProjection.fromLatLngToContainerPixel(marker.getPosition());\n            return point([projectedPoint.x, projectedPoint.y]);\n        }));\n        const grouped = [];\n        clustersDbscan(points, this.maxDistance, this.options).features.forEach((point, i) => {\n            if (!grouped[point.properties.cluster]) {\n                grouped[point.properties.cluster] = [];\n            }\n            grouped[point.properties.cluster].push(markers[i]);\n        });\n        return grouped.map((markers) => new Cluster({ markers }));\n    }\n}\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * A very fast JavaScript algorithm for geospatial point clustering using KD trees.\n *\n * @see https://www.npmjs.com/package/supercluster for more information on options.\n */\nclass SuperClusterAlgorithm extends AbstractAlgorithm {\n    constructor(_a) {\n        var { maxZoom, radius = 60 } = _a, options = __rest(_a, [\"maxZoom\", \"radius\"]);\n        super({ maxZoom });\n        this.superCluster = new SuperCluster(Object.assign({ maxZoom: this.maxZoom, radius }, options));\n        this.state = { zoom: null };\n    }\n    calculate(input) {\n        let changed = false;\n        if (!equal(input.markers, this.markers)) {\n            changed = true;\n            // TODO use proxy to avoid copy?\n            this.markers = [...input.markers];\n            const points = this.markers.map((marker) => {\n                return {\n                    type: \"Feature\",\n                    geometry: {\n                        type: \"Point\",\n                        coordinates: [\n                            marker.getPosition().lng(),\n                            marker.getPosition().lat(),\n                        ],\n                    },\n                    properties: { marker },\n                };\n            });\n            this.superCluster.load(points);\n        }\n        const state = { zoom: input.map.getZoom() };\n        if (!changed) {\n            if (this.state.zoom > this.maxZoom && state.zoom > this.maxZoom) ;\n            else {\n                changed = changed || !equal(this.state, state);\n            }\n        }\n        this.state = state;\n        if (changed) {\n            this.clusters = this.cluster(input);\n        }\n        return { clusters: this.clusters, changed };\n    }\n    cluster({ map }) {\n        return this.superCluster\n            .getClusters([-180, -90, 180, 90], Math.round(map.getZoom()))\n            .map(this.transformCluster.bind(this));\n    }\n    transformCluster({ geometry: { coordinates: [lng, lat], }, properties, }) {\n        if (properties.cluster) {\n            return new Cluster({\n                markers: this.superCluster\n                    .getLeaves(properties.cluster_id, Infinity)\n                    .map((leaf) => leaf.properties.marker),\n                position: new google.maps.LatLng({ lat, lng }),\n            });\n        }\n        else {\n            const marker = properties.marker;\n            return new Cluster({\n                markers: [marker],\n                position: marker.getPosition(),\n            });\n        }\n    }\n}\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Provides statistics on all clusters in the current render cycle for use in {@link Renderer.render}.\n */\nclass ClusterStats {\n    constructor(markers, clusters) {\n        this.markers = { sum: markers.length };\n        const clusterMarkerCounts = clusters.map((a) => a.count);\n        const clusterMarkerSum = clusterMarkerCounts.reduce((a, b) => a + b, 0);\n        this.clusters = {\n            count: clusters.length,\n            markers: {\n                mean: clusterMarkerSum / clusters.length,\n                sum: clusterMarkerSum,\n                min: Math.min(...clusterMarkerCounts),\n                max: Math.max(...clusterMarkerCounts),\n            },\n        };\n    }\n}\nclass DefaultRenderer {\n    /**\n     * The default render function for the library used by {@link MarkerClusterer}.\n     *\n     * Currently set to use the following:\n     *\n     * ```typescript\n     * // change color if this cluster has more markers than the mean cluster\n     * const color =\n     *   count > Math.max(10, stats.clusters.markers.mean)\n     *     ? \"#ff0000\"\n     *     : \"#0000ff\";\n     *\n     * // create svg url with fill color\n     * const svg = window.btoa(`\n     * <svg fill=\"${color}\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 240 240\">\n     *   <circle cx=\"120\" cy=\"120\" opacity=\".6\" r=\"70\" />\n     *   <circle cx=\"120\" cy=\"120\" opacity=\".3\" r=\"90\" />\n     *   <circle cx=\"120\" cy=\"120\" opacity=\".2\" r=\"110\" />\n     *   <circle cx=\"120\" cy=\"120\" opacity=\".1\" r=\"130\" />\n     * </svg>`);\n     *\n     * // create marker using svg icon\n     * return new google.maps.Marker({\n     *   position,\n     *   icon: {\n     *     url: `data:image/svg+xml;base64,${svg}`,\n     *     scaledSize: new google.maps.Size(45, 45),\n     *   },\n     *   label: {\n     *     text: String(count),\n     *     color: \"rgba(255,255,255,0.9)\",\n     *     fontSize: \"12px\",\n     *   },\n     *   // adjust zIndex to be above other markers\n     *   zIndex: 1000 + count,\n     * });\n     * ```\n     */\n    render({ count, position }, stats) {\n        // change color if this cluster has more markers than the mean cluster\n        const color = count > Math.max(10, stats.clusters.markers.mean) ? \"#ff0000\" : \"#0000ff\";\n        // create svg url with fill color\n        const svg = window.btoa(`\n  <svg fill=\"${color}\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 240 240\">\n    <circle cx=\"120\" cy=\"120\" opacity=\".6\" r=\"70\" />\n    <circle cx=\"120\" cy=\"120\" opacity=\".3\" r=\"90\" />\n    <circle cx=\"120\" cy=\"120\" opacity=\".2\" r=\"110\" />\n  </svg>`);\n        // create marker using svg icon\n        return new google.maps.Marker({\n            position,\n            icon: {\n                url: `data:image/svg+xml;base64,${svg}`,\n                scaledSize: new google.maps.Size(45, 45),\n            },\n            label: {\n                text: String(count),\n                color: \"rgba(255,255,255,0.9)\",\n                fontSize: \"12px\",\n            },\n            title: `Cluster of ${count} markers`,\n            // adjust zIndex to be above other markers\n            zIndex: Number(google.maps.Marker.MAX_ZINDEX) + count,\n        });\n    }\n}\n\n/**\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Extends an object's prototype by another's.\n *\n * @param type1 The Type to be extended.\n * @param type2 The Type to extend with.\n * @ignore\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction extend(type1, type2) {\n    /* istanbul ignore next */\n    // eslint-disable-next-line prefer-const\n    for (let property in type2.prototype) {\n        type1.prototype[property] = type2.prototype[property];\n    }\n}\n/**\n * @ignore\n */\nclass OverlayViewSafe {\n    constructor() {\n        // MarkerClusterer implements google.maps.OverlayView interface. We use the\n        // extend function to extend MarkerClusterer with google.maps.OverlayView\n        // because it might not always be available when the code is defined so we\n        // look for it at the last possible moment. If it doesn't exist now then\n        // there is no point going ahead :)\n        extend(OverlayViewSafe, google.maps.OverlayView);\n    }\n}\n\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar MarkerClustererEvents;\n(function (MarkerClustererEvents) {\n    MarkerClustererEvents[\"CLUSTERING_BEGIN\"] = \"clusteringbegin\";\n    MarkerClustererEvents[\"CLUSTERING_END\"] = \"clusteringend\";\n    MarkerClustererEvents[\"CLUSTER_CLICK\"] = \"click\";\n})(MarkerClustererEvents || (MarkerClustererEvents = {}));\nconst defaultOnClusterClickHandler = (_, cluster, map) => {\n    map.fitBounds(cluster.bounds);\n};\n/**\n * MarkerClusterer creates and manages per-zoom-level clusters for large amounts\n * of markers. See {@link MarkerClustererOptions} for more details.\n *\n */\nclass MarkerClusterer extends OverlayViewSafe {\n    constructor({ map, markers = [], algorithm = new SuperClusterAlgorithm({}), renderer = new DefaultRenderer(), onClusterClick = defaultOnClusterClickHandler, }) {\n        super();\n        this.markers = [...markers];\n        this.clusters = [];\n        this.algorithm = algorithm;\n        this.renderer = renderer;\n        this.onClusterClick = onClusterClick;\n        if (map) {\n            this.setMap(map);\n        }\n    }\n    addMarker(marker, noDraw) {\n        if (this.markers.includes(marker)) {\n            return;\n        }\n        this.markers.push(marker);\n        if (!noDraw) {\n            this.render();\n        }\n    }\n    addMarkers(markers, noDraw) {\n        markers.forEach((marker) => {\n            this.addMarker(marker, true);\n        });\n        if (!noDraw) {\n            this.render();\n        }\n    }\n    removeMarker(marker, noDraw) {\n        const index = this.markers.indexOf(marker);\n        if (index === -1) {\n            // Marker is not in our list of markers, so do nothing:\n            return false;\n        }\n        marker.setMap(null);\n        this.markers.splice(index, 1); // Remove the marker from the list of managed markers\n        if (!noDraw) {\n            this.render();\n        }\n        return true;\n    }\n    removeMarkers(markers, noDraw) {\n        let removed = false;\n        markers.forEach((marker) => {\n            removed = this.removeMarker(marker, true) || removed;\n        });\n        if (removed && !noDraw) {\n            this.render();\n        }\n        return removed;\n    }\n    clearMarkers(noDraw) {\n        this.markers.length = 0;\n        if (!noDraw) {\n            this.render();\n        }\n    }\n    /**\n     * Recalculates and draws all the marker clusters.\n     */\n    render() {\n        const map = this.getMap();\n        if (map instanceof google.maps.Map && this.getProjection()) {\n            google.maps.event.trigger(this, MarkerClustererEvents.CLUSTERING_BEGIN, this);\n            const { clusters, changed } = this.algorithm.calculate({\n                markers: this.markers,\n                map,\n                mapCanvasProjection: this.getProjection(),\n            });\n            // allow algorithms to return flag on whether the clusters/markers have changed\n            if (changed || changed == undefined) {\n                // reset visibility of markers and clusters\n                this.reset();\n                // store new clusters\n                this.clusters = clusters;\n                this.renderClusters();\n            }\n            google.maps.event.trigger(this, MarkerClustererEvents.CLUSTERING_END, this);\n        }\n    }\n    onAdd() {\n        this.idleListener = this.getMap().addListener(\"idle\", this.render.bind(this));\n        this.render();\n    }\n    onRemove() {\n        google.maps.event.removeListener(this.idleListener);\n        this.reset();\n    }\n    reset() {\n        this.markers.forEach((marker) => marker.setMap(null));\n        this.clusters.forEach((cluster) => cluster.delete());\n        this.clusters = [];\n    }\n    renderClusters() {\n        // generate stats to pass to renderers\n        const stats = new ClusterStats(this.markers, this.clusters);\n        const map = this.getMap();\n        this.clusters.forEach((cluster) => {\n            if (cluster.markers.length === 1) {\n                cluster.marker = cluster.markers[0];\n            }\n            else {\n                cluster.marker = this.renderer.render(cluster, stats);\n                if (this.onClusterClick) {\n                    cluster.marker.addListener(\"click\", \n                    /* istanbul ignore next */\n                    (event) => {\n                        google.maps.event.trigger(this, MarkerClustererEvents.CLUSTER_CLICK, cluster);\n                        this.onClusterClick(event, cluster, map);\n                    });\n                }\n            }\n            cluster.marker.setMap(map);\n        });\n    }\n}\n\nexport { AbstractAlgorithm, AbstractViewportAlgorithm, Cluster, ClusterStats, DBScanAlgorithm, DefaultRenderer, GridAlgorithm, KmeansAlgorithm, MarkerClusterer, MarkerClustererEvents, NoopAlgorithm, SuperClusterAlgorithm, defaultOnClusterClickHandler, distanceBetweenPoints, extendBoundsToPaddedViewport, extendPixelBounds, filterMarkersToPaddedViewport, noop, pixelBoundsToLatLngBounds };\n//# sourceMappingURL=index.esm.js.map\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isArray = require('../internals/is-array');\n\nvar nativeReverse = uncurryThis([].reverse);\nvar test = [1, 2];\n\n// `Array.prototype.reverse` method\n// https://tc39.es/ecma262/#sec-array.prototype.reverse\n// fix for Safari 12.0 bug\n// https://bugs.webkit.org/show_bug.cgi?id=188794\n$({ target: 'Array', proto: true, forced: String(test) === String(test.reverse()) }, {\n  reverse: function reverse() {\n    // eslint-disable-next-line no-self-assign -- dirty hack\n    if (isArray(this)) this.length = this.length;\n    return nativeReverse(this);\n  }\n});\n","var global = require('../internals/global');\nvar setToStringTag = require('../internals/set-to-string-tag');\n\n// JSON[@@toStringTag] property\n// https://tc39.es/ecma262/#sec-json-@@tostringtag\nsetToStringTag(global.JSON, 'JSON', true);\n","var setToStringTag = require('../internals/set-to-string-tag');\n\n// Math[@@toStringTag] property\n// https://tc39.es/ecma262/#sec-math-@@tostringtag\nsetToStringTag(Math, 'Math', true);\n","var $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar toObject = require('../internals/to-object');\nvar nativeGetPrototypeOf = require('../internals/object-get-prototype-of');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar FAILS_ON_PRIMITIVES = fails(function () { nativeGetPrototypeOf(1); });\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !CORRECT_PROTOTYPE_GETTER }, {\n  getPrototypeOf: function getPrototypeOf(it) {\n    return nativeGetPrototypeOf(toObject(it));\n  }\n});\n\n","var defineWellKnownSymbol = require('../internals/well-known-symbol-define');\n\n// `Symbol.asyncIterator` well-known symbol\n// https://tc39.es/ecma262/#sec-symbol.asynciterator\ndefineWellKnownSymbol('asyncIterator');\n","var defineWellKnownSymbol = require('../internals/well-known-symbol-define');\n\n// `Symbol.iterator` well-known symbol\n// https://tc39.es/ecma262/#sec-symbol.iterator\ndefineWellKnownSymbol('iterator');\n","var getBuiltIn = require('../internals/get-built-in');\nvar defineWellKnownSymbol = require('../internals/well-known-symbol-define');\nvar setToStringTag = require('../internals/set-to-string-tag');\n\n// `Symbol.toStringTag` well-known symbol\n// https://tc39.es/ecma262/#sec-symbol.tostringtag\ndefineWellKnownSymbol('toStringTag');\n\n// `Symbol.prototype[@@toStringTag]` property\n// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag\nsetToStringTag(getBuiltIn('Symbol'), 'Symbol');\n","/**\r\n * DBSCAN - Density based clustering\r\n *\r\n * @author Lukasz Krawczyk <contact@lukaszkrawczyk.eu>\r\n * @copyright MIT\r\n */\r\n\r\n/**\r\n * DBSCAN class construcotr\r\n * @constructor\r\n *\r\n * @param {Array} dataset\r\n * @param {number} epsilon\r\n * @param {number} minPts\r\n * @param {function} distanceFunction\r\n * @returns {DBSCAN}\r\n */\r\nfunction DBSCAN(dataset, epsilon, minPts, distanceFunction) {\r\n  /** @type {Array} */\r\n  this.dataset = [];\r\n  /** @type {number} */\r\n  this.epsilon = 1;\r\n  /** @type {number} */\r\n  this.minPts = 2;\r\n  /** @type {function} */\r\n  this.distance = this._euclideanDistance;\r\n  /** @type {Array} */\r\n  this.clusters = [];\r\n  /** @type {Array} */\r\n  this.noise = [];\r\n\r\n  // temporary variables used during computation\r\n\r\n  /** @type {Array} */\r\n  this._visited = [];\r\n  /** @type {Array} */\r\n  this._assigned = [];\r\n  /** @type {number} */\r\n  this._datasetLength = 0;\r\n\r\n  this._init(dataset, epsilon, minPts, distanceFunction);\r\n};\r\n\r\n/******************************************************************************/\r\n// public functions\r\n\r\n/**\r\n * Start clustering\r\n *\r\n * @param {Array} dataset\r\n * @param {number} epsilon\r\n * @param {number} minPts\r\n * @param {function} distanceFunction\r\n * @returns {undefined}\r\n * @access public\r\n */\r\nDBSCAN.prototype.run = function(dataset, epsilon, minPts, distanceFunction) {\r\n  this._init(dataset, epsilon, minPts, distanceFunction);\r\n\r\n  for (var pointId = 0; pointId < this._datasetLength; pointId++) {\r\n    // if point is not visited, check if it forms a cluster\r\n    if (this._visited[pointId] !== 1) {\r\n      this._visited[pointId] = 1;\r\n\r\n      // if closest neighborhood is too small to form a cluster, mark as noise\r\n      var neighbors = this._regionQuery(pointId);\r\n\r\n      if (neighbors.length < this.minPts) {\r\n        this.noise.push(pointId);\r\n      } else {\r\n        // create new cluster and add point\r\n        var clusterId = this.clusters.length;\r\n        this.clusters.push([]);\r\n        this._addToCluster(pointId, clusterId);\r\n\r\n        this._expandCluster(clusterId, neighbors);\r\n      }\r\n    }\r\n  }\r\n\r\n  return this.clusters;\r\n};\r\n\r\n/******************************************************************************/\r\n// protected functions\r\n\r\n/**\r\n * Set object properties\r\n *\r\n * @param {Array} dataset\r\n * @param {number} epsilon\r\n * @param {number} minPts\r\n * @param {function} distance\r\n * @returns {undefined}\r\n * @access protected\r\n */\r\nDBSCAN.prototype._init = function(dataset, epsilon, minPts, distance) {\r\n\r\n  if (dataset) {\r\n\r\n    if (!(dataset instanceof Array)) {\r\n      throw Error('Dataset must be of type array, ' +\r\n        typeof dataset + ' given');\r\n    }\r\n\r\n    this.dataset = dataset;\r\n    this.clusters = [];\r\n    this.noise = [];\r\n\r\n    this._datasetLength = dataset.length;\r\n    this._visited = new Array(this._datasetLength);\r\n    this._assigned = new Array(this._datasetLength);\r\n  }\r\n\r\n  if (epsilon) {\r\n    this.epsilon = epsilon;\r\n  }\r\n\r\n  if (minPts) {\r\n    this.minPts = minPts;\r\n  }\r\n\r\n  if (distance) {\r\n    this.distance = distance;\r\n  }\r\n};\r\n\r\n/**\r\n * Expand cluster to closest points of given neighborhood\r\n *\r\n * @param {number} clusterId\r\n * @param {Array} neighbors\r\n * @returns {undefined}\r\n * @access protected\r\n */\r\nDBSCAN.prototype._expandCluster = function(clusterId, neighbors) {\r\n\r\n  /**\r\n   * It's very important to calculate length of neighbors array each time,\r\n   * as the number of elements changes over time\r\n   */\r\n  for (var i = 0; i < neighbors.length; i++) {\r\n    var pointId2 = neighbors[i];\r\n\r\n    if (this._visited[pointId2] !== 1) {\r\n      this._visited[pointId2] = 1;\r\n      var neighbors2 = this._regionQuery(pointId2);\r\n\r\n      if (neighbors2.length >= this.minPts) {\r\n        neighbors = this._mergeArrays(neighbors, neighbors2);\r\n      }\r\n    }\r\n\r\n    // add to cluster\r\n    if (this._assigned[pointId2] !== 1) {\r\n      this._addToCluster(pointId2, clusterId);\r\n    }\r\n  }\r\n};\r\n\r\n/**\r\n * Add new point to cluster\r\n *\r\n * @param {number} pointId\r\n * @param {number} clusterId\r\n */\r\nDBSCAN.prototype._addToCluster = function(pointId, clusterId) {\r\n  this.clusters[clusterId].push(pointId);\r\n  this._assigned[pointId] = 1;\r\n};\r\n\r\n/**\r\n * Find all neighbors around given point\r\n *\r\n * @param {number} pointId,\r\n * @param {number} epsilon\r\n * @returns {Array}\r\n * @access protected\r\n */\r\nDBSCAN.prototype._regionQuery = function(pointId) {\r\n  var neighbors = [];\r\n\r\n  for (var id = 0; id < this._datasetLength; id++) {\r\n    var dist = this.distance(this.dataset[pointId], this.dataset[id]);\r\n    if (dist < this.epsilon) {\r\n      neighbors.push(id);\r\n    }\r\n  }\r\n\r\n  return neighbors;\r\n};\r\n\r\n/******************************************************************************/\r\n// helpers\r\n\r\n/**\r\n * @param {Array} a\r\n * @param {Array} b\r\n * @returns {Array}\r\n * @access protected\r\n */\r\nDBSCAN.prototype._mergeArrays = function(a, b) {\r\n  var len = b.length;\r\n\r\n  for (var i = 0; i < len; i++) {\r\n    var P = b[i];\r\n    if (a.indexOf(P) < 0) {\r\n      a.push(P);\r\n    }\r\n  }\r\n\r\n  return a;\r\n};\r\n\r\n/**\r\n * Calculate euclidean distance in multidimensional space\r\n *\r\n * @param {Array} p\r\n * @param {Array} q\r\n * @returns {number}\r\n * @access protected\r\n */\r\nDBSCAN.prototype._euclideanDistance = function(p, q) {\r\n  var sum = 0;\r\n  var i = Math.min(p.length, q.length);\r\n\r\n  while (i--) {\r\n    sum += (p[i] - q[i]) * (p[i] - q[i]);\r\n  }\r\n\r\n  return Math.sqrt(sum);\r\n};\r\n\r\nif (typeof module !== 'undefined' && module.exports) {\r\n  module.exports = DBSCAN;\r\n}\r\n","/**\r\n * KMEANS clustering\r\n *\r\n * @author Lukasz Krawczyk <contact@lukaszkrawczyk.eu>\r\n * @copyright MIT\r\n */\r\n\r\n/**\r\n * KMEANS class constructor\r\n * @constructor\r\n *\r\n * @param {Array} dataset\r\n * @param {number} k - number of clusters\r\n * @param {function} distance - distance function\r\n * @returns {KMEANS}\r\n */\r\n function KMEANS(dataset, k, distance) {\r\n  this.k = 3; // number of clusters\r\n  this.dataset = []; // set of feature vectors\r\n  this.assignments = []; // set of associated clusters for each feature vector\r\n  this.centroids = []; // vectors for our clusters\r\n\r\n  this.init(dataset, k, distance);\r\n}\r\n\r\n/**\r\n * @returns {undefined}\r\n */\r\nKMEANS.prototype.init = function(dataset, k, distance) {\r\n  this.assignments = [];\r\n  this.centroids = [];\r\n\r\n  if (typeof dataset !== 'undefined') {\r\n    this.dataset = dataset;\r\n  }\r\n\r\n  if (typeof k !== 'undefined') {\r\n    this.k = k;\r\n  }\r\n\r\n  if (typeof distance !== 'undefined') {\r\n    this.distance = distance;\r\n  }\r\n};\r\n\r\n/**\r\n * @returns {undefined}\r\n */\r\nKMEANS.prototype.run = function(dataset, k) {\r\n  this.init(dataset, k);\r\n\r\n  var len = this.dataset.length;\r\n\r\n  // initialize centroids\r\n  for (var i = 0; i < this.k; i++) {\r\n    this.centroids[i] = this.randomCentroid();\r\n\t}\r\n\r\n  var change = true;\r\n  while(change) {\r\n\r\n    // assign feature vectors to clusters\r\n    change = this.assign();\r\n\r\n    // adjust location of centroids\r\n    for (var centroidId = 0; centroidId < this.k; centroidId++) {\r\n      var mean = new Array(maxDim);\r\n      var count = 0;\r\n\r\n      // init mean vector\r\n      for (var dim = 0; dim < maxDim; dim++) {\r\n        mean[dim] = 0;\r\n      }\r\n\r\n      for (var j = 0; j < len; j++) {\r\n        var maxDim = this.dataset[j].length;\r\n\r\n        // if current cluster id is assigned to point\r\n        if (centroidId === this.assignments[j]) {\r\n          for (var dim = 0; dim < maxDim; dim++) {\r\n            mean[dim] += this.dataset[j][dim];\r\n          }\r\n          count++;\r\n        }\r\n      }\r\n\r\n      if (count > 0) {\r\n        // if cluster contain points, adjust centroid position\r\n        for (var dim = 0; dim < maxDim; dim++) {\r\n          mean[dim] /= count;\r\n        }\r\n        this.centroids[centroidId] = mean;\r\n      } else {\r\n        // if cluster is empty, generate new random centroid\r\n        this.centroids[centroidId] = this.randomCentroid();\r\n        change = true;\r\n      }\r\n    }\r\n  }\r\n\r\n  return this.getClusters();\r\n};\r\n\r\n/**\r\n * Generate random centroid\r\n *\r\n * @returns {Array}\r\n */\r\nKMEANS.prototype.randomCentroid = function() {\r\n  var maxId = this.dataset.length -1;\r\n  var centroid;\r\n  var id;\r\n\r\n  do {\r\n    id = Math.round(Math.random() * maxId);\r\n    centroid = this.dataset[id];\r\n  } while (this.centroids.indexOf(centroid) >= 0);\r\n\r\n  return centroid;\r\n}\r\n\r\n/**\r\n * Assign points to clusters\r\n *\r\n * @returns {boolean}\r\n */\r\nKMEANS.prototype.assign = function() {\r\n  var change = false;\r\n  var len = this.dataset.length;\r\n  var closestCentroid;\r\n\r\n  for (var i = 0; i < len; i++) {\r\n    closestCentroid = this.argmin(this.dataset[i], this.centroids, this.distance);\r\n\r\n    if (closestCentroid != this.assignments[i]) {\r\n      this.assignments[i] = closestCentroid;\r\n      change = true;\r\n    }\r\n  }\r\n\r\n  return change;\r\n}\r\n\r\n/**\r\n * Extract information about clusters\r\n *\r\n * @returns {undefined}\r\n */\r\nKMEANS.prototype.getClusters = function() {\r\n  var clusters = new Array(this.k);\r\n  var centroidId;\r\n\r\n  for (var pointId = 0; pointId < this.assignments.length; pointId++) {\r\n    centroidId = this.assignments[pointId];\r\n\r\n    // init empty cluster\r\n    if (typeof clusters[centroidId] === 'undefined') {\r\n      clusters[centroidId] = [];\r\n    }\r\n\r\n    clusters[centroidId].push(pointId);\r\n  }\r\n\r\n  return clusters;\r\n};\r\n\r\n// utils\r\n\r\n/**\r\n * @params {Array} point\r\n * @params {Array.<Array>} set\r\n * @params {Function} f\r\n * @returns {number}\r\n */\r\nKMEANS.prototype.argmin = function(point, set, f) {\r\n  var min = Number.MAX_VALUE;\r\n  var arg = 0;\r\n  var len = set.length;\r\n  var d;\r\n\r\n  for (var i = 0; i < len; i++) {\r\n    d = f(point, set[i]);\r\n    if (d < min) {\r\n      min = d;\r\n      arg = i;\r\n    }\r\n  }\r\n\r\n  return arg;\r\n};\r\n\r\n/**\r\n * Euclidean distance\r\n *\r\n * @params {number} p\r\n * @params {number} q\r\n * @returns {number}\r\n */\r\nKMEANS.prototype.distance = function(p, q) {\r\n  var sum = 0;\r\n  var i = Math.min(p.length, q.length);\r\n\r\n  while (i--) {\r\n    var diff = p[i] - q[i];\r\n    sum += diff * diff;\r\n  }\r\n\r\n  return Math.sqrt(sum);\r\n};\r\n\r\nif (typeof module !== 'undefined' && module.exports) {\r\n  module.exports = KMEANS;\r\n}\r\n","\r\n/**\r\n * @requires ./PriorityQueue.js\r\n */\r\n\r\nif (typeof module !== 'undefined' && module.exports) {\r\n      var PriorityQueue = require('./PriorityQueue.js');\r\n}\r\n\r\n/**\r\n * OPTICS - Ordering points to identify the clustering structure\r\n *\r\n * @author Lukasz Krawczyk <contact@lukaszkrawczyk.eu>\r\n * @copyright MIT\r\n */\r\n\r\n/**\r\n * OPTICS class constructor\r\n * @constructor\r\n *\r\n * @param {Array} dataset\r\n * @param {number} epsilon\r\n * @param {number} minPts\r\n * @param {function} distanceFunction\r\n * @returns {OPTICS}\r\n */\r\nfunction OPTICS(dataset, epsilon, minPts, distanceFunction) {\r\n  /** @type {number} */\r\n  this.epsilon = 1;\r\n  /** @type {number} */\r\n  this.minPts = 1;\r\n  /** @type {function} */\r\n  this.distance = this._euclideanDistance;\r\n\r\n  // temporary variables used during computation\r\n\r\n  /** @type {Array} */\r\n  this._reachability = [];\r\n  /** @type {Array} */\r\n  this._processed = [];\r\n  /** @type {number} */\r\n  this._coreDistance = 0;\r\n  /** @type {Array} */\r\n  this._orderedList = [];\r\n\r\n  this._init(dataset, epsilon, minPts, distanceFunction);\r\n}\r\n\r\n/******************************************************************************/\r\n// pulic functions\r\n\r\n/**\r\n * Start clustering\r\n *\r\n * @param {Array} dataset\r\n * @returns {undefined}\r\n * @access public\r\n */\r\nOPTICS.prototype.run = function(dataset, epsilon, minPts, distanceFunction) {\r\n  this._init(dataset, epsilon, minPts, distanceFunction);\r\n\r\n  for (var pointId = 0, l = this.dataset.length; pointId < l; pointId++) {\r\n    if (this._processed[pointId] !== 1) {\r\n      this._processed[pointId] = 1;\r\n      this.clusters.push([pointId]);\r\n      var clusterId = this.clusters.length - 1;\r\n\r\n      this._orderedList.push(pointId);\r\n      var priorityQueue = new PriorityQueue(null, null, 'asc');\r\n      var neighbors = this._regionQuery(pointId);\r\n\r\n      // using priority queue assign elements to new cluster\r\n      if (this._distanceToCore(pointId) !== undefined) {\r\n        this._updateQueue(pointId, neighbors, priorityQueue);\r\n        this._expandCluster(clusterId, priorityQueue);\r\n      }\r\n    }\r\n  }\r\n\r\n  return this.clusters;\r\n};\r\n\r\n/**\r\n * Generate reachability plot for all points\r\n *\r\n * @returns {array}\r\n * @access public\r\n */\r\nOPTICS.prototype.getReachabilityPlot = function() {\r\n  var reachabilityPlot = [];\r\n\r\n  for (var i = 0, l = this._orderedList.length; i < l; i++) {\r\n    var pointId = this._orderedList[i];\r\n    var distance = this._reachability[pointId];\r\n\r\n    reachabilityPlot.push([pointId, distance]);\r\n  }\r\n\r\n  return reachabilityPlot;\r\n};\r\n\r\n/******************************************************************************/\r\n// protected functions\r\n\r\n/**\r\n * Set object properties\r\n *\r\n * @param {Array} dataset\r\n * @param {number} epsilon\r\n * @param {number} minPts\r\n * @param {function} distance\r\n * @returns {undefined}\r\n * @access protected\r\n */\r\nOPTICS.prototype._init = function(dataset, epsilon, minPts, distance) {\r\n\r\n  if (dataset) {\r\n\r\n    if (!(dataset instanceof Array)) {\r\n      throw Error('Dataset must be of type array, ' +\r\n        typeof dataset + ' given');\r\n    }\r\n\r\n    this.dataset = dataset;\r\n    this.clusters = [];\r\n    this._reachability = new Array(this.dataset.length);\r\n    this._processed = new Array(this.dataset.length);\r\n    this._coreDistance = 0;\r\n    this._orderedList = [];\r\n  }\r\n\r\n  if (epsilon) {\r\n    this.epsilon = epsilon;\r\n  }\r\n\r\n  if (minPts) {\r\n    this.minPts = minPts;\r\n  }\r\n\r\n  if (distance) {\r\n    this.distance = distance;\r\n  }\r\n};\r\n\r\n/**\r\n * Update information in queue\r\n *\r\n * @param {number} pointId\r\n * @param {Array} neighbors\r\n * @param {PriorityQueue} queue\r\n * @returns {undefined}\r\n * @access protected\r\n */\r\nOPTICS.prototype._updateQueue = function(pointId, neighbors, queue) {\r\n  var self = this;\r\n\r\n  this._coreDistance = this._distanceToCore(pointId);\r\n  neighbors.forEach(function(pointId2) {\r\n    if (self._processed[pointId2] === undefined) {\r\n      var dist = self.distance(self.dataset[pointId], self.dataset[pointId2]);\r\n      var newReachableDistance = Math.max(self._coreDistance, dist);\r\n\r\n      if (self._reachability[pointId2] === undefined) {\r\n        self._reachability[pointId2] = newReachableDistance;\r\n        queue.insert(pointId2, newReachableDistance);\r\n      } else {\r\n        if (newReachableDistance < self._reachability[pointId2]) {\r\n          self._reachability[pointId2] = newReachableDistance;\r\n          queue.remove(pointId2);\r\n          queue.insert(pointId2, newReachableDistance);\r\n        }\r\n      }\r\n    }\r\n  });\r\n};\r\n\r\n/**\r\n * Expand cluster\r\n *\r\n * @param {number} clusterId\r\n * @param {PriorityQueue} queue\r\n * @returns {undefined}\r\n * @access protected\r\n */\r\nOPTICS.prototype._expandCluster = function(clusterId, queue) {\r\n  var queueElements = queue.getElements();\r\n\r\n  for (var p = 0, l = queueElements.length; p < l; p++) {\r\n    var pointId = queueElements[p];\r\n    if (this._processed[pointId] === undefined) {\r\n      var neighbors = this._regionQuery(pointId);\r\n      this._processed[pointId] = 1;\r\n\r\n      this.clusters[clusterId].push(pointId);\r\n      this._orderedList.push(pointId);\r\n\r\n      if (this._distanceToCore(pointId) !== undefined) {\r\n        this._updateQueue(pointId, neighbors, queue);\r\n        this._expandCluster(clusterId, queue);\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\n/**\r\n * Calculating distance to cluster core\r\n *\r\n * @param {number} pointId\r\n * @returns {number}\r\n * @access protected\r\n */\r\nOPTICS.prototype._distanceToCore = function(pointId) {\r\n  var l = this.epsilon;\r\n  for (var coreDistCand = 0; coreDistCand < l; coreDistCand++) {\r\n    var neighbors = this._regionQuery(pointId, coreDistCand);\r\n    if (neighbors.length >= this.minPts) {\r\n      return coreDistCand;\r\n    }\r\n  }\r\n\r\n  return;\r\n};\r\n\r\n/**\r\n * Find all neighbors around given point\r\n *\r\n * @param {number} pointId\r\n * @param {number} epsilon\r\n * @returns {Array}\r\n * @access protected\r\n */\r\nOPTICS.prototype._regionQuery = function(pointId, epsilon) {\r\n  epsilon = epsilon || this.epsilon;\r\n  var neighbors = [];\r\n\r\n  for (var id = 0, l = this.dataset.length; id < l; id++) {\r\n    if (this.distance(this.dataset[pointId], this.dataset[id]) < epsilon) {\r\n      neighbors.push(id);\r\n    }\r\n  }\r\n\r\n  return neighbors;\r\n};\r\n\r\n/******************************************************************************/\r\n// helpers\r\n\r\n/**\r\n * Calculate euclidean distance in multidimensional space\r\n *\r\n * @param {Array} p\r\n * @param {Array} q\r\n * @returns {number}\r\n * @access protected\r\n */\r\nOPTICS.prototype._euclideanDistance = function(p, q) {\r\n  var sum = 0;\r\n  var i = Math.min(p.length, q.length);\r\n\r\n  while (i--) {\r\n    sum += (p[i] - q[i]) * (p[i] - q[i]);\r\n  }\r\n\r\n  return Math.sqrt(sum);\r\n};\r\n\r\nif (typeof module !== 'undefined' && module.exports) {\r\n  module.exports = OPTICS;\r\n}\r\n","/**\r\n * PriorityQueue\r\n * Elements in this queue are sorted according to their value\r\n *\r\n * @author Lukasz Krawczyk <contact@lukaszkrawczyk.eu>\r\n * @copyright MIT\r\n */\r\n\r\n/**\r\n * PriorityQueue class construcotr\r\n * @constructor\r\n *\r\n * @example\r\n * queue: [1,2,3,4]\r\n * priorities: [4,1,2,3]\r\n * > result = [1,4,2,3]\r\n *\r\n * @param {Array} elements\r\n * @param {Array} priorities\r\n * @param {string} sorting - asc / desc\r\n * @returns {PriorityQueue}\r\n */\r\nfunction PriorityQueue(elements, priorities, sorting) {\r\n  /** @type {Array} */\r\n  this._queue = [];\r\n  /** @type {Array} */\r\n  this._priorities = [];\r\n  /** @type {string} */\r\n  this._sorting = 'desc';\r\n\r\n  this._init(elements, priorities, sorting);\r\n};\r\n\r\n/**\r\n * Insert element\r\n *\r\n * @param {Object} ele\r\n * @param {Object} priority\r\n * @returns {undefined}\r\n * @access public\r\n */\r\nPriorityQueue.prototype.insert = function(ele, priority) {\r\n  var indexToInsert = this._queue.length;\r\n  var index = indexToInsert;\r\n\r\n  while (index--) {\r\n    var priority2 = this._priorities[index];\r\n    if (this._sorting === 'desc') {\r\n      if (priority > priority2) {\r\n        indexToInsert = index;\r\n      }\r\n    } else {\r\n      if (priority < priority2) {\r\n        indexToInsert = index;\r\n      }\r\n    }\r\n  }\r\n\r\n  this._insertAt(ele, priority, indexToInsert);\r\n};\r\n\r\n/**\r\n * Remove element\r\n *\r\n * @param {Object} ele\r\n * @returns {undefined}\r\n * @access public\r\n */\r\nPriorityQueue.prototype.remove = function(ele) {\r\n  var index = this._queue.length;\r\n\r\n  while (index--) {\r\n    var ele2 = this._queue[index];\r\n    if (ele === ele2) {\r\n      this._queue.splice(index, 1);\r\n      this._priorities.splice(index, 1);\r\n      break;\r\n    }\r\n  }\r\n};\r\n\r\n/**\r\n * For each loop wrapper\r\n *\r\n * @param {function} func\r\n * @returs {undefined}\r\n * @access public\r\n */\r\nPriorityQueue.prototype.forEach = function(func) {\r\n  this._queue.forEach(func);\r\n};\r\n\r\n/**\r\n * @returns {Array}\r\n * @access public\r\n */\r\nPriorityQueue.prototype.getElements = function() {\r\n  return this._queue;\r\n};\r\n\r\n/**\r\n * @param {number} index\r\n * @returns {Object}\r\n * @access public\r\n */\r\nPriorityQueue.prototype.getElementPriority = function(index) {\r\n  return this._priorities[index];\r\n};\r\n\r\n/**\r\n * @returns {Array}\r\n * @access public\r\n */\r\nPriorityQueue.prototype.getPriorities = function() {\r\n  return this._priorities;\r\n};\r\n\r\n/**\r\n * @returns {Array}\r\n * @access public\r\n */\r\nPriorityQueue.prototype.getElementsWithPriorities = function() {\r\n  var result = [];\r\n\r\n  for (var i = 0, l = this._queue.length; i < l; i++) {\r\n    result.push([this._queue[i], this._priorities[i]]);\r\n  }\r\n\r\n  return result;\r\n};\r\n\r\n/**\r\n * Set object properties\r\n *\r\n * @param {Array} elements\r\n * @param {Array} priorities\r\n * @returns {undefined}\r\n * @access protected\r\n */\r\nPriorityQueue.prototype._init = function(elements, priorities, sorting) {\r\n\r\n  if (elements && priorities) {\r\n    this._queue = [];\r\n    this._priorities = [];\r\n\r\n    if (elements.length !== priorities.length) {\r\n      throw new Error('Arrays must have the same length');\r\n    }\r\n\r\n    for (var i = 0; i < elements.length; i++) {\r\n      this.insert(elements[i], priorities[i]);\r\n    }\r\n  }\r\n\r\n  if (sorting) {\r\n    this._sorting = sorting;\r\n  }\r\n};\r\n\r\n/**\r\n * Insert element at given position\r\n *\r\n * @param {Object} ele\r\n * @param {number} index\r\n * @returns {undefined}\r\n * @access protected\r\n */\r\nPriorityQueue.prototype._insertAt = function(ele, priority, index) {\r\n  if (this._queue.length === index) {\r\n    this._queue.push(ele);\r\n    this._priorities.push(priority);\r\n  } else {\r\n    this._queue.splice(index, 0, ele);\r\n    this._priorities.splice(index, 0, priority);\r\n  }\r\n};\r\n\r\nif (typeof module !== 'undefined' && module.exports) {\r\n  module.exports = PriorityQueue;\r\n}\r\n","\r\nif (typeof module !== 'undefined' && module.exports) {\r\n    module.exports = {\r\n      DBSCAN: require('./DBSCAN.js'),\r\n      KMEANS: require('./KMEANS.js'),\r\n      OPTICS: require('./OPTICS.js'),\r\n      PriorityQueue: require('./PriorityQueue.js')\r\n    };\r\n}\r\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n  var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n    if ((a instanceof Map) && (b instanceof Map)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      for (i of a.entries())\n        if (!equal(i[1], b.get(i[0]))) return false;\n      return true;\n    }\n\n    if ((a instanceof Set) && (b instanceof Set)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      return true;\n    }\n\n    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (a[i] !== b[i]) return false;\n      return true;\n    }\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","\"use strict\";\n\nmodule.exports = {\n\t/**\n  * Euclidean distance\n  */\n\teudist: function eudist(v1, v2, sqrt) {\n\t\tvar len = v1.length;\n\t\tvar sum = 0;\n\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tvar d = (v1[i] || 0) - (v2[i] || 0);\n\t\t\tsum += d * d;\n\t\t}\n\t\t// Square root not really needed\n\t\treturn sqrt ? Math.sqrt(sum) : sum;\n\t},\n\tmandist: function mandist(v1, v2, sqrt) {\n\t\tvar len = v1.length;\n\t\tvar sum = 0;\n\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tsum += Math.abs((v1[i] || 0) - (v2[i] || 0));\n\t\t}\n\n\t\t// Square root not really needed\n\t\treturn sqrt ? Math.sqrt(sum) : sum;\n\t},\n\n\n\t/**\n  * Unidimensional distance\n  */\n\tdist: function dist(v1, v2, sqrt) {\n\t\tvar d = Math.abs(v1 - v2);\n\t\treturn sqrt ? d : d * d;\n\t}\n};\n//# sourceMappingURL=distance.js.map\n","\"use strict\";\n\nvar Distance = require(\"./distance.js\"),\n    eudist = Distance.eudist,\n    dist = Distance.dist;\n\nmodule.exports = {\n\tkmrand: function kmrand(data, k) {\n\t\tvar map = {},\n\t\t    ks = [],\n\t\t    t = k << 2;\n\t\tvar len = data.length;\n\t\tvar multi = data[0].length > 0;\n\n\t\twhile (ks.length < k && t-- > 0) {\n\t\t\tvar d = data[Math.floor(Math.random() * len)];\n\t\t\tvar key = multi ? d.join(\"_\") : \"\" + d;\n\t\t\tif (!map[key]) {\n\t\t\t\tmap[key] = true;\n\t\t\t\tks.push(d);\n\t\t\t}\n\t\t}\n\n\t\tif (ks.length < k) throw new Error(\"Error initializating clusters\");else return ks;\n\t},\n\n\n\t/**\n  * K-means++ initial centroid selection\n  */\n\tkmpp: function kmpp(data, k) {\n\t\tvar distance = data[0].length ? eudist : dist;\n\t\tvar ks = [],\n\t\t    len = data.length;\n\t\tvar multi = data[0].length > 0;\n\t\tvar map = {};\n\n\t\t// First random centroid\n\t\tvar c = data[Math.floor(Math.random() * len)];\n\t\tvar key = multi ? c.join(\"_\") : \"\" + c;\n\t\tks.push(c);\n\t\tmap[key] = true;\n\n\t\t// Retrieve next centroids\n\t\twhile (ks.length < k) {\n\t\t\t// Min Distances between current centroids and data points\n\t\t\tvar dists = [],\n\t\t\t    lk = ks.length;\n\t\t\tvar dsum = 0,\n\t\t\t    prs = [];\n\n\t\t\tfor (var i = 0; i < len; i++) {\n\t\t\t\tvar min = Infinity;\n\t\t\t\tfor (var j = 0; j < lk; j++) {\n\t\t\t\t\tvar _dist = distance(data[i], ks[j]);\n\t\t\t\t\tif (_dist <= min) min = _dist;\n\t\t\t\t}\n\t\t\t\tdists[i] = min;\n\t\t\t}\n\n\t\t\t// Sum all min distances\n\t\t\tfor (var _i = 0; _i < len; _i++) {\n\t\t\t\tdsum += dists[_i];\n\t\t\t}\n\n\t\t\t// Probabilities and cummulative prob (cumsum)\n\t\t\tfor (var _i2 = 0; _i2 < len; _i2++) {\n\t\t\t\tprs[_i2] = { i: _i2, v: data[_i2], pr: dists[_i2] / dsum, cs: 0 };\n\t\t\t}\n\n\t\t\t// Sort Probabilities\n\t\t\tprs.sort(function (a, b) {\n\t\t\t\treturn a.pr - b.pr;\n\t\t\t});\n\n\t\t\t// Cummulative Probabilities\n\t\t\tprs[0].cs = prs[0].pr;\n\t\t\tfor (var _i3 = 1; _i3 < len; _i3++) {\n\t\t\t\tprs[_i3].cs = prs[_i3 - 1].cs + prs[_i3].pr;\n\t\t\t}\n\n\t\t\t// Randomize\n\t\t\tvar rnd = Math.random();\n\n\t\t\t// Gets only the items whose cumsum >= rnd\n\t\t\tvar idx = 0;\n\t\t\twhile (idx < len - 1 && prs[idx++].cs < rnd) {}\n\t\t\tks.push(prs[idx - 1].v);\n\t\t\t/*\n   let done = false;\n   while(!done) {\n   \t// this is our new centroid\n   \tc = prs[idx-1].v\n   \tkey = multi? c.join(\"_\") : `${c}`;\n   \tif(!map[key]) {\n   \t\tmap[key] = true;\n   \t\tks.push(c);\n   \t\tdone = true;\n   \t}\n   \telse {\n   \t\tidx++;\n   \t}\n   }\n   */\n\t\t}\n\n\t\treturn ks;\n\t}\n};\n//# sourceMappingURL=kinit.js.map\n","\"use strict\";\n\n/*jshint esversion: 6 */\n\nvar Distance = require(\"./distance.js\"),\n    ClusterInit = require(\"./kinit.js\"),\n    eudist = Distance.eudist,\n    mandist = Distance.mandist,\n    dist = Distance.dist,\n    kmrand = ClusterInit.kmrand,\n    kmpp = ClusterInit.kmpp;\n\nvar MAX = 10000;\n\n/**\n * Inits an array with values\n */\nfunction init(len, val, v) {\n\tv = v || [];\n\tfor (var i = 0; i < len; i++) {\n\t\tv[i] = val;\n\t}return v;\n}\n\nfunction skmeans(data, k, initial, maxit) {\n\tvar ks = [],\n\t    old = [],\n\t    idxs = [],\n\t    dist = [];\n\tvar conv = false,\n\t    it = maxit || MAX;\n\tvar len = data.length,\n\t    vlen = data[0].length,\n\t    multi = vlen > 0;\n\tvar count = [];\n\n\tif (!initial) {\n\t\tvar _idxs = {};\n\t\twhile (ks.length < k) {\n\t\t\tvar idx = Math.floor(Math.random() * len);\n\t\t\tif (!_idxs[idx]) {\n\t\t\t\t_idxs[idx] = true;\n\t\t\t\tks.push(data[idx]);\n\t\t\t}\n\t\t}\n\t} else if (initial == \"kmrand\") {\n\t\tks = kmrand(data, k);\n\t} else if (initial == \"kmpp\") {\n\t\tks = kmpp(data, k);\n\t} else {\n\t\tks = initial;\n\t}\n\n\tdo {\n\t\t// Reset k count\n\t\tinit(k, 0, count);\n\n\t\t// For each value in data, find the nearest centroid\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tvar min = Infinity,\n\t\t\t    _idx = 0;\n\t\t\tfor (var j = 0; j < k; j++) {\n\t\t\t\t// Multidimensional or unidimensional\n\t\t\t\tvar dist = multi ? eudist(data[i], ks[j]) : Math.abs(data[i] - ks[j]);\n\t\t\t\tif (dist <= min) {\n\t\t\t\t\tmin = dist;\n\t\t\t\t\t_idx = j;\n\t\t\t\t}\n\t\t\t}\n\t\t\tidxs[i] = _idx; // Index of the selected centroid for that value\n\t\t\tcount[_idx]++; // Number of values for this centroid\n\t\t}\n\n\t\t// Recalculate centroids\n\t\tvar sum = [],\n\t\t    old = [],\n\t\t    dif = 0;\n\t\tfor (var _j = 0; _j < k; _j++) {\n\t\t\t// Multidimensional or unidimensional\n\t\t\tsum[_j] = multi ? init(vlen, 0, sum[_j]) : 0;\n\t\t\told[_j] = ks[_j];\n\t\t}\n\n\t\t// If multidimensional\n\t\tif (multi) {\n\t\t\tfor (var _j2 = 0; _j2 < k; _j2++) {\n\t\t\t\tks[_j2] = [];\n\t\t\t} // Sum values and count for each centroid\n\t\t\tfor (var _i = 0; _i < len; _i++) {\n\t\t\t\tvar _idx2 = idxs[_i],\n\t\t\t\t    // Centroid for that item\n\t\t\t\tvsum = sum[_idx2],\n\t\t\t\t    // Sum values for this centroid\n\t\t\t\tvect = data[_i]; // Current vector\n\n\t\t\t\t// Accumulate value on the centroid for current vector\n\t\t\t\tfor (var h = 0; h < vlen; h++) {\n\t\t\t\t\tvsum[h] += vect[h];\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Calculate the average for each centroid\n\t\t\tconv = true;\n\t\t\tfor (var _j3 = 0; _j3 < k; _j3++) {\n\t\t\t\tvar ksj = ks[_j3],\n\t\t\t\t    // Current centroid\n\t\t\t\tsumj = sum[_j3],\n\t\t\t\t    // Accumulated centroid values\n\t\t\t\toldj = old[_j3],\n\t\t\t\t    // Old centroid value\n\t\t\t\tcj = count[_j3]; // Number of elements for this centroid\n\n\t\t\t\t// New average\n\t\t\t\tfor (var _h = 0; _h < vlen; _h++) {\n\t\t\t\t\tksj[_h] = sumj[_h] / cj || 0; // New centroid\n\t\t\t\t}\n\n\t\t\t\t// Find if centroids have moved\n\t\t\t\tif (conv) {\n\t\t\t\t\tfor (var _h2 = 0; _h2 < vlen; _h2++) {\n\t\t\t\t\t\tif (oldj[_h2] != ksj[_h2]) {\n\t\t\t\t\t\t\tconv = false;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t// If unidimensional\n\t\telse {\n\t\t\t\t// Sum values and count for each centroid\n\t\t\t\tfor (var _i2 = 0; _i2 < len; _i2++) {\n\t\t\t\t\tvar _idx3 = idxs[_i2];\n\t\t\t\t\tsum[_idx3] += data[_i2];\n\t\t\t\t}\n\t\t\t\t// Calculate the average for each centroid\n\t\t\t\tfor (var _j4 = 0; _j4 < k; _j4++) {\n\t\t\t\t\tks[_j4] = sum[_j4] / count[_j4] || 0; // New centroid\n\t\t\t\t}\n\t\t\t\t// Find if centroids have moved\n\t\t\t\tconv = true;\n\t\t\t\tfor (var _j5 = 0; _j5 < k; _j5++) {\n\t\t\t\t\tif (old[_j5] != ks[_j5]) {\n\t\t\t\t\t\tconv = false;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\tconv = conv || --it <= 0;\n\t} while (!conv);\n\n\treturn {\n\t\tit: MAX - it,\n\t\tk: k,\n\t\tidxs: idxs,\n\t\tcentroids: ks\n\t};\n}\n\nmodule.exports = skmeans;\n//# sourceMappingURL=main.js.map\n"],"names":["sortKD","ids","coords","nodeSize","left","right","depth","m","k","inc","n","z","Math","log","s","exp","sd","sqrt","max","floor","min","t","i","j","swapItem","swap","arr","tmp","sqDist","ax","ay","bx","by","dx","dy","defaultGetX","p","defaultGetY","KDBush","constructor","points","getX","getY","ArrayType","Float64Array","this","IndexArrayType","length","Uint16Array","Uint32Array","range","minX","minY","maxX","maxY","stack","result","x","y","axis","pop","push","nextAxis","within","r","qx","qy","r2","defaultOptions","minZoom","maxZoom","minPoints","radius","extent","generateId","reduce","map","props","fround","Float32Array","Supercluster","options","extend","Object","create","trees","Array","load","console","time","timerId","clusters","geometry","createPointCluster","timeEnd","now","Date","_cluster","getClusters","bbox","zoom","minLng","minLat","maxLng","maxLat","easternHem","westernHem","concat","tree","_limitZoom","lngX","latY","id","c","numPoints","getClusterJSON","index","getChildren","clusterId","originId","_getOriginId","originZoom","_getOriginZoom","errorMsg","Error","origin","pow","children","parentId","getLeaves","limit","offset","leaves","_appendLeaves","getTile","z2","top","bottom","tile","features","_addTileFeatures","getClusterExpansionZoom","expansionZoom","properties","cluster_id","skipped","child","cluster","point_count","isCluster","tags","px","py","getClusterProperties","coordinates","f","type","round","undefined","neighborIds","numPointsOrigin","neighborId","b","wx","wy","clusterProperties","_map","numPoints2","createCluster","point","clone","original","Infinity","yLat","count","abbrev","point_count_abbreviated","lng","lat","sin","PI","y2","atan","dest","src","Cluster","markers","position","google","maps","LatLng","_position","bounds","marker","getPosition","LatLngBounds","getCenter","filter","getVisible","delete","setMap","noop","SuperClusterAlgorithm","_a","e","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","propertyIsEnumerable","__rest","super","superCluster","assign","state","calculate","input","changed","getZoom","transformCluster","bind","leaf","ClusterStats","sum","clusterMarkerCounts","a","clusterMarkerSum","mean","DefaultRenderer","render","stats","color","svg","window","btoa","Marker","icon","url","scaledSize","Size","label","text","String","fontSize","title","zIndex","Number","MAX_ZINDEX","OverlayViewSafe","type1","type2","property","OverlayView","MarkerClustererEvents","defaultOnClusterClickHandler","_","fitBounds","MarkerClusterer","algorithm","renderer","onClusterClick","addMarker","noDraw","includes","addMarkers","forEach","removeMarker","splice","removeMarkers","removed","clearMarkers","getMap","Map","getProjection","event","trigger","CLUSTERING_BEGIN","mapCanvasProjection","reset","renderClusters","CLUSTERING_END","onAdd","idleListener","addListener","onRemove","removeListener","CLUSTER_CLICK","$","uncurryThis","isArray","nativeReverse","reverse","test","target","proto","forced","global","setToStringTag","JSON","fails","toObject","nativeGetPrototypeOf","CORRECT_PROTOTYPE_GETTER","stat","sham","getPrototypeOf","it","defineWellKnownSymbol","getBuiltIn","DBSCAN","dataset","epsilon","minPts","distanceFunction","distance","_euclideanDistance","noise","_visited","_assigned","_datasetLength","_init","run","pointId","neighbors","_regionQuery","_addToCluster","_expandCluster","pointId2","neighbors2","_mergeArrays","len","P","q","module","exports","KMEANS","assignments","centroids","init","randomCentroid","change","centroidId","maxDim","dim","centroid","maxId","random","closestCentroid","argmin","set","d","MAX_VALUE","arg","diff","PriorityQueue","OPTICS","_reachability","_processed","_coreDistance","_orderedList","l","priorityQueue","_distanceToCore","_updateQueue","getReachabilityPlot","reachabilityPlot","queue","self","dist","newReachableDistance","insert","remove","queueElements","getElements","coreDistCand","elements","priorities","sorting","_queue","_priorities","_sorting","ele","priority","indexToInsert","priority2","_insertAt","func","getElementPriority","getPriorities","getElementsWithPriorities","equal","keys","size","entries","has","get","Set","ArrayBuffer","isView","RegExp","source","flags","valueOf","toString","key","eudist","v1","v2","mandist","abs","Distance","kmrand","data","ks","multi","join","kmpp","dists","lk","dsum","prs","_dist","_i","_i2","v","pr","cs","sort","_i3","rnd","idx","ClusterInit","val","initial","maxit","old","idxs","conv","vlen","_idxs","_idx","_j","_j2","vsum","vect","h","_j3","ksj","sumj","oldj","cj","_h","_h2","_j4","_j5"],"sourceRoot":""}