{"version":3,"file":"static/chunks/3074.dc6123d29b8d65c0.js","mappings":"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","sources":["webpack://_N_E/./node_modules/invariant/browser.js","webpack://_N_E/./node_modules/points-cluster/lib/index.js","webpack://_N_E/./node_modules/points-cluster/lib/utils/createTree.js","webpack://_N_E/./node_modules/points-cluster/lib/utils/latLng.js","webpack://_N_E/./node_modules/rbush/rbush.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  }\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error(\n        'Minified exception occurred; use the non-minified dev environment ' +\n        'for the full error message and additional helpful warnings.'\n      );\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(\n        format.replace(/%s/g, function() { return args[argIndex++]; })\n      );\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n};\n\nmodule.exports = invariant;\n","'use strict';\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _invariant = require('invariant');\n\nvar _invariant2 = _interopRequireDefault(_invariant);\n\nvar _latLng = require('./utils/latLng');\n\nvar _createTree = require('./utils/createTree');\n\nvar _createTree2 = _interopRequireDefault(_createTree);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nvar createCluster = function createCluster(x, y, points) {\n  return {\n    x: x, // cluster center\n    y: y,\n    wx: x, // weighted cluster center\n    wy: y,\n    zoom: Infinity, // the last zoom the cluster was processed at\n    points: points,\n    numPoints: points.length\n  };\n};\n\n// squared distance between two points\nfunction distSq(a, b) {\n  var dx = a.wx - b.wx;\n  var dy = a.wy - b.wy;\n  return dx * dx + dy * dy;\n}\n\nfunction SuperCluster(options) {\n  this.options = _extends({}, this.options, options);\n\n  this._initTrees();\n}\n\nSuperCluster.prototype = {\n  options: {\n    minZoom: 0, // min zoom to generate clusters on\n    maxZoom: 16, // max zoom level to cluster the points on\n    radius: 40, // cluster radius in pixels\n    extent: 512, // tile extent (radius is calculated relative to it)\n    nodeSize: 16 },\n\n  // size of the R-tree leaf node, affects performance\n  load: function load(points) {\n    // generate a cluster object for each point\n    var clusters = points.map(function (_ref) {\n      var pt = _objectWithoutProperties(_ref, []);\n\n      var lat = _ref.lat;\n      var lng = _ref.lng;\n      return createCluster(lng, lat, [pt]);\n    });\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 (var z = this.options.maxZoom; z >= this.options.minZoom; z--) {\n      this.trees[z + 1].load(clusters); // index input points into an R-tree\n      clusters = this._cluster(clusters, z); // create a new set of clusters for the zoom\n    }\n    this.trees[this.options.minZoom].load(clusters); // index top-level clusters\n\n    return this;\n  },\n  getClusters: function getClusters(bbox, zoom) {\n    var _this = this;\n\n    var _bbox = _slicedToArray(bbox, 4);\n\n    var nwLng = _bbox[0];\n    var seLat = _bbox[1];\n    var seLng = _bbox[2];\n    var nwLat = _bbox[3];\n\n    var z = Math.max(this.options.minZoom, Math.min(zoom, this.options.maxZoom + 1));\n    var bBoxes = nwLng < seLng ? [bbox] : [[nwLng, seLat, 180, nwLat], [-180, seLat, seLng, nwLat]];\n\n    var clusters = bBoxes.map(function (bBox) {\n      return _this.trees[z].search(bBox);\n    }).reduce(function (r, lst) {\n      return [].concat(_toConsumableArray(r), _toConsumableArray(lst));\n    }, []);\n\n    return clusters;\n  },\n  _initTrees: function _initTrees() {\n    this.trees = [];\n    // make an R-Tree index for each zoom level\n    for (var z = 0; z <= this.options.maxZoom + 1; z++) {\n      this.trees[z] = (0, _createTree2.default)(this.options.nodeSize);\n    }\n  },\n  _cluster: function _cluster(points, zoom) {\n    var clusters = [];\n    var r = (0, _latLng.screenDist2LatLngDist)(this.options.radius, zoom);\n    var bbox = [0, 0, 0, 0];\n\n    // loop through each point\n    for (var i = 0; i < points.length; i++) {\n      var p = points[i];\n      var clusterPoints = p.points;\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 with a bbox search\n      bbox[0] = p.wx - r;\n      bbox[1] = p.wy - r;\n      bbox[2] = p.wx + r;\n      bbox[3] = p.wy + r;\n      var bboxNeighbors = this.trees[zoom + 1].search(bbox);\n\n      var foundNeighbors = false;\n      var numPoints = p.numPoints;\n      var wx = p.wx * numPoints;\n      var wy = p.wy * numPoints;\n\n      for (var j = 0; j < bboxNeighbors.length; j++) {\n        var b = bboxNeighbors[j];\n        // filter out neighbors that are too far or already processed\n        if (zoom < b.zoom && distSq(p, b) <= r * r) {\n          foundNeighbors = true;\n          b.zoom = zoom; // save the zoom (so it doesn't get processed twice)\n          wx += b.wx * b.numPoints; // accumulate coordinates for calculating weighted center\n          wy += b.wy * b.numPoints;\n          numPoints += b.numPoints;\n          clusterPoints = [].concat(_toConsumableArray(clusterPoints), _toConsumableArray(b.points));\n        }\n      }\n\n      if (!foundNeighbors) {\n        clusters.push(p); // no neighbors, add a single point as cluster\n        continue;\n      }\n\n      // form a cluster with neighbors\n      var cluster = createCluster(p.x, p.y, clusterPoints);\n      (0, _invariant2.default)(clusterPoints.length === numPoints, 'clusterPoints.length === numPoints');\n\n      // save weighted cluster center for display\n      cluster.wx = wx / numPoints;\n      cluster.wy = wy / numPoints;\n\n      clusters.push(cluster);\n    }\n\n    return clusters;\n  }\n};\n\nvar supercluster = function supercluster(points, options) {\n  var cl = new SuperCluster(options);\n  cl.load(points);\n\n  return function (_ref2) {\n    var _ref2$bounds = _ref2.bounds;\n    var nw = _ref2$bounds.nw;\n    var se = _ref2$bounds.se;\n    var zoom = _ref2.zoom;\n    return cl.getClusters([nw.lng, se.lat, se.lng, nw.lat], zoom);\n  };\n};\n\nexports.default = supercluster;\n\n/*\nconst cl = supercluster([\n  { lat: 10, lng: 10 },\n  { lat: 10.1, lng: 10.1 },\n  { lat: 12, lng: 12 },\n  { lat: 84, lng: 179 },\n]);\n\nconst r = cl({ bounds: { nw: { lat: 85, lng: -180 }, se: { lat: -85, lng: 180 } }, zoom: 2 });\n\nconsole.log(JSON.stringify(r));\n*/","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _rbush = require('rbush');\n\nvar _rbush2 = _interopRequireDefault(_rbush);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar toBBox = function toBBox(p) {\n  return [p.x, p.y, p.x, p.y];\n};\nvar compareMinX = function compareMinX(a, b) {\n  return a.x - b.x;\n};\nvar compareMinY = function compareMinY(a, b) {\n  return a.y - b.y;\n};\n\nexports.default = function (nodeSize) {\n  var tree = (0, _rbush2.default)(nodeSize);\n  tree.toBBox = toBBox;\n  tree.compareMinX = compareMinX;\n  tree.compareMinY = compareMinY;\n  return tree;\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\n// longitude/latitude to spherical mercator in [0..1] range\nvar lngX = exports.lngX = function lngX(lng) {\n  return lng / 360 + 0.5;\n};\n\nvar latY = exports.latY = function latY(lat) {\n  var sin = Math.sin(lat * Math.PI / 180);\n  var y = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;\n\n  return y < 0 ? 0 : y > 1 ? 1 : y;\n};\n\nvar TILE_SIZE = 256;\n\nvar screenDist2LatLngDist = exports.screenDist2LatLngDist = function screenDist2LatLngDist(dist, zoom) {\n  var scale = Math.pow(2, zoom);\n  var distW = dist / scale / TILE_SIZE;\n  var distLatLng = distW * 360;\n  return distLatLng;\n};\n\n/*\n// spherical mercator to longitude/latitude\nexport const xLng = (x) => (x - 0.5) * 360;\n\nexport const yLat = (y) =>\n  360 * Math.atan(Math.exp((180 - y * 360) * Math.PI / 180)) / Math.PI - 90;\n*/","/*\n (c) 2015, Vladimir Agafonkin\n RBush, a JavaScript library for high-performance 2D spatial indexing of points and rectangles.\n https://github.com/mourner/rbush\n*/\n\n(function () {\n'use strict';\n\nfunction rbush(maxEntries, format) {\n    if (!(this instanceof rbush)) return new rbush(maxEntries, format);\n\n    // max entries in a node is 9 by default; min node fill is 40% for best performance\n    this._maxEntries = Math.max(4, maxEntries || 9);\n    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));\n\n    if (format) {\n        this._initFormat(format);\n    }\n\n    this.clear();\n}\n\nrbush.prototype = {\n\n    all: function () {\n        return this._all(this.data, []);\n    },\n\n    search: function (bbox) {\n\n        var node = this.data,\n            result = [],\n            toBBox = this.toBBox;\n\n        if (!intersects(bbox, node.bbox)) return result;\n\n        var nodesToSearch = [],\n            i, len, child, childBBox;\n\n        while (node) {\n            for (i = 0, len = node.children.length; i < len; i++) {\n\n                child = node.children[i];\n                childBBox = node.leaf ? toBBox(child) : child.bbox;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf) result.push(child);\n                    else if (contains(bbox, childBBox)) this._all(child, result);\n                    else nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return result;\n    },\n\n    collides: function (bbox) {\n\n        var node = this.data,\n            toBBox = this.toBBox;\n\n        if (!intersects(bbox, node.bbox)) return false;\n\n        var nodesToSearch = [],\n            i, len, child, childBBox;\n\n        while (node) {\n            for (i = 0, len = node.children.length; i < len; i++) {\n\n                child = node.children[i];\n                childBBox = node.leaf ? toBBox(child) : child.bbox;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf || contains(bbox, childBBox)) return true;\n                    nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return false;\n    },\n\n    load: function (data) {\n        if (!(data && data.length)) return this;\n\n        if (data.length < this._minEntries) {\n            for (var i = 0, len = data.length; i < len; i++) {\n                this.insert(data[i]);\n            }\n            return this;\n        }\n\n        // recursively build the tree with the given data from stratch using OMT algorithm\n        var node = this._build(data.slice(), 0, data.length - 1, 0);\n\n        if (!this.data.children.length) {\n            // save as is if tree is empty\n            this.data = node;\n\n        } else if (this.data.height === node.height) {\n            // split root if trees have the same height\n            this._splitRoot(this.data, node);\n\n        } else {\n            if (this.data.height < node.height) {\n                // swap trees if inserted one is bigger\n                var tmpNode = this.data;\n                this.data = node;\n                node = tmpNode;\n            }\n\n            // insert the small tree into the large tree at appropriate level\n            this._insert(node, this.data.height - node.height - 1, true);\n        }\n\n        return this;\n    },\n\n    insert: function (item) {\n        if (item) this._insert(item, this.data.height - 1);\n        return this;\n    },\n\n    clear: function () {\n        this.data = {\n            children: [],\n            height: 1,\n            bbox: empty(),\n            leaf: true\n        };\n        return this;\n    },\n\n    remove: function (item) {\n        if (!item) return this;\n\n        var node = this.data,\n            bbox = this.toBBox(item),\n            path = [],\n            indexes = [],\n            i, parent, index, goingUp;\n\n        // depth-first iterative tree traversal\n        while (node || path.length) {\n\n            if (!node) { // go up\n                node = path.pop();\n                parent = path[path.length - 1];\n                i = indexes.pop();\n                goingUp = true;\n            }\n\n            if (node.leaf) { // check current node\n                index = node.children.indexOf(item);\n\n                if (index !== -1) {\n                    // item found, remove the item and condense tree upwards\n                    node.children.splice(index, 1);\n                    path.push(node);\n                    this._condense(path);\n                    return this;\n                }\n            }\n\n            if (!goingUp && !node.leaf && contains(node.bbox, bbox)) { // go down\n                path.push(node);\n                indexes.push(i);\n                i = 0;\n                parent = node;\n                node = node.children[0];\n\n            } else if (parent) { // go right\n                i++;\n                node = parent.children[i];\n                goingUp = false;\n\n            } else node = null; // nothing found\n        }\n\n        return this;\n    },\n\n    toBBox: function (item) { return item; },\n\n    compareMinX: function (a, b) { return a[0] - b[0]; },\n    compareMinY: function (a, b) { return a[1] - b[1]; },\n\n    toJSON: function () { return this.data; },\n\n    fromJSON: function (data) {\n        this.data = data;\n        return this;\n    },\n\n    _all: function (node, result) {\n        var nodesToSearch = [];\n        while (node) {\n            if (node.leaf) result.push.apply(result, node.children);\n            else nodesToSearch.push.apply(nodesToSearch, node.children);\n\n            node = nodesToSearch.pop();\n        }\n        return result;\n    },\n\n    _build: function (items, left, right, height) {\n\n        var N = right - left + 1,\n            M = this._maxEntries,\n            node;\n\n        if (N <= M) {\n            // reached leaf level; return leaf\n            node = {\n                children: items.slice(left, right + 1),\n                height: 1,\n                bbox: null,\n                leaf: true\n            };\n            calcBBox(node, this.toBBox);\n            return node;\n        }\n\n        if (!height) {\n            // target height of the bulk-loaded tree\n            height = Math.ceil(Math.log(N) / Math.log(M));\n\n            // target number of root entries to maximize storage utilization\n            M = Math.ceil(N / Math.pow(M, height - 1));\n        }\n\n        node = {\n            children: [],\n            height: height,\n            bbox: null,\n            leaf: false\n        };\n\n        // split the items into M mostly square tiles\n\n        var N2 = Math.ceil(N / M),\n            N1 = N2 * Math.ceil(Math.sqrt(M)),\n            i, j, right2, right3;\n\n        multiSelect(items, left, right, N1, this.compareMinX);\n\n        for (i = left; i <= right; i += N1) {\n\n            right2 = Math.min(i + N1 - 1, right);\n\n            multiSelect(items, i, right2, N2, this.compareMinY);\n\n            for (j = i; j <= right2; j += N2) {\n\n                right3 = Math.min(j + N2 - 1, right2);\n\n                // pack each entry recursively\n                node.children.push(this._build(items, j, right3, height - 1));\n            }\n        }\n\n        calcBBox(node, this.toBBox);\n\n        return node;\n    },\n\n    _chooseSubtree: function (bbox, node, level, path) {\n\n        var i, len, child, targetNode, area, enlargement, minArea, minEnlargement;\n\n        while (true) {\n            path.push(node);\n\n            if (node.leaf || path.length - 1 === level) break;\n\n            minArea = minEnlargement = Infinity;\n\n            for (i = 0, len = node.children.length; i < len; i++) {\n                child = node.children[i];\n                area = bboxArea(child.bbox);\n                enlargement = enlargedArea(bbox, child.bbox) - area;\n\n                // choose entry with the least area enlargement\n                if (enlargement < minEnlargement) {\n                    minEnlargement = enlargement;\n                    minArea = area < minArea ? area : minArea;\n                    targetNode = child;\n\n                } else if (enlargement === minEnlargement) {\n                    // otherwise choose one with the smallest area\n                    if (area < minArea) {\n                        minArea = area;\n                        targetNode = child;\n                    }\n                }\n            }\n\n            node = targetNode || node.children[0];\n        }\n\n        return node;\n    },\n\n    _insert: function (item, level, isNode) {\n\n        var toBBox = this.toBBox,\n            bbox = isNode ? item.bbox : toBBox(item),\n            insertPath = [];\n\n        // find the best node for accommodating the item, saving all nodes along the path too\n        var node = this._chooseSubtree(bbox, this.data, level, insertPath);\n\n        // put the item into the node\n        node.children.push(item);\n        extend(node.bbox, bbox);\n\n        // split on node overflow; propagate upwards if necessary\n        while (level >= 0) {\n            if (insertPath[level].children.length > this._maxEntries) {\n                this._split(insertPath, level);\n                level--;\n            } else break;\n        }\n\n        // adjust bboxes along the insertion path\n        this._adjustParentBBoxes(bbox, insertPath, level);\n    },\n\n    // split overflowed node into two\n    _split: function (insertPath, level) {\n\n        var node = insertPath[level],\n            M = node.children.length,\n            m = this._minEntries;\n\n        this._chooseSplitAxis(node, m, M);\n\n        var splitIndex = this._chooseSplitIndex(node, m, M);\n\n        var newNode = {\n            children: node.children.splice(splitIndex, node.children.length - splitIndex),\n            height: node.height,\n            bbox: null,\n            leaf: false\n        };\n\n        if (node.leaf) newNode.leaf = true;\n\n        calcBBox(node, this.toBBox);\n        calcBBox(newNode, this.toBBox);\n\n        if (level) insertPath[level - 1].children.push(newNode);\n        else this._splitRoot(node, newNode);\n    },\n\n    _splitRoot: function (node, newNode) {\n        // split root node\n        this.data = {\n            children: [node, newNode],\n            height: node.height + 1,\n            bbox: null,\n            leaf: false\n        };\n        calcBBox(this.data, this.toBBox);\n    },\n\n    _chooseSplitIndex: function (node, m, M) {\n\n        var i, bbox1, bbox2, overlap, area, minOverlap, minArea, index;\n\n        minOverlap = minArea = Infinity;\n\n        for (i = m; i <= M - m; i++) {\n            bbox1 = distBBox(node, 0, i, this.toBBox);\n            bbox2 = distBBox(node, i, M, this.toBBox);\n\n            overlap = intersectionArea(bbox1, bbox2);\n            area = bboxArea(bbox1) + bboxArea(bbox2);\n\n            // choose distribution with minimum overlap\n            if (overlap < minOverlap) {\n                minOverlap = overlap;\n                index = i;\n\n                minArea = area < minArea ? area : minArea;\n\n            } else if (overlap === minOverlap) {\n                // otherwise choose distribution with minimum area\n                if (area < minArea) {\n                    minArea = area;\n                    index = i;\n                }\n            }\n        }\n\n        return index;\n    },\n\n    // sorts node children by the best axis for split\n    _chooseSplitAxis: function (node, m, M) {\n\n        var compareMinX = node.leaf ? this.compareMinX : compareNodeMinX,\n            compareMinY = node.leaf ? this.compareMinY : compareNodeMinY,\n            xMargin = this._allDistMargin(node, m, M, compareMinX),\n            yMargin = this._allDistMargin(node, m, M, compareMinY);\n\n        // if total distributions margin value is minimal for x, sort by minX,\n        // otherwise it's already sorted by minY\n        if (xMargin < yMargin) node.children.sort(compareMinX);\n    },\n\n    // total margin of all possible split distributions where each node is at least m full\n    _allDistMargin: function (node, m, M, compare) {\n\n        node.children.sort(compare);\n\n        var toBBox = this.toBBox,\n            leftBBox = distBBox(node, 0, m, toBBox),\n            rightBBox = distBBox(node, M - m, M, toBBox),\n            margin = bboxMargin(leftBBox) + bboxMargin(rightBBox),\n            i, child;\n\n        for (i = m; i < M - m; i++) {\n            child = node.children[i];\n            extend(leftBBox, node.leaf ? toBBox(child) : child.bbox);\n            margin += bboxMargin(leftBBox);\n        }\n\n        for (i = M - m - 1; i >= m; i--) {\n            child = node.children[i];\n            extend(rightBBox, node.leaf ? toBBox(child) : child.bbox);\n            margin += bboxMargin(rightBBox);\n        }\n\n        return margin;\n    },\n\n    _adjustParentBBoxes: function (bbox, path, level) {\n        // adjust bboxes along the given tree path\n        for (var i = level; i >= 0; i--) {\n            extend(path[i].bbox, bbox);\n        }\n    },\n\n    _condense: function (path) {\n        // go through the path, removing empty nodes and updating bboxes\n        for (var i = path.length - 1, siblings; i >= 0; i--) {\n            if (path[i].children.length === 0) {\n                if (i > 0) {\n                    siblings = path[i - 1].children;\n                    siblings.splice(siblings.indexOf(path[i]), 1);\n\n                } else this.clear();\n\n            } else calcBBox(path[i], this.toBBox);\n        }\n    },\n\n    _initFormat: function (format) {\n        // data format (minX, minY, maxX, maxY accessors)\n\n        // uses eval-type function compilation instead of just accepting a toBBox function\n        // because the algorithms are very sensitive to sorting functions performance,\n        // so they should be dead simple and without inner calls\n\n        var compareArr = ['return a', ' - b', ';'];\n\n        this.compareMinX = new Function('a', 'b', compareArr.join(format[0]));\n        this.compareMinY = new Function('a', 'b', compareArr.join(format[1]));\n\n        this.toBBox = new Function('a', 'return [a' + format.join(', a') + '];');\n    }\n};\n\n\n// calculate node's bbox from bboxes of its children\nfunction calcBBox(node, toBBox) {\n    node.bbox = distBBox(node, 0, node.children.length, toBBox);\n}\n\n// min bounding rectangle of node children from k to p-1\nfunction distBBox(node, k, p, toBBox) {\n    var bbox = empty();\n\n    for (var i = k, child; i < p; i++) {\n        child = node.children[i];\n        extend(bbox, node.leaf ? toBBox(child) : child.bbox);\n    }\n\n    return bbox;\n}\n\nfunction empty() { return [Infinity, Infinity, -Infinity, -Infinity]; }\n\nfunction extend(a, b) {\n    a[0] = Math.min(a[0], b[0]);\n    a[1] = Math.min(a[1], b[1]);\n    a[2] = Math.max(a[2], b[2]);\n    a[3] = Math.max(a[3], b[3]);\n    return a;\n}\n\nfunction compareNodeMinX(a, b) { return a.bbox[0] - b.bbox[0]; }\nfunction compareNodeMinY(a, b) { return a.bbox[1] - b.bbox[1]; }\n\nfunction bboxArea(a)   { return (a[2] - a[0]) * (a[3] - a[1]); }\nfunction bboxMargin(a) { return (a[2] - a[0]) + (a[3] - a[1]); }\n\nfunction enlargedArea(a, b) {\n    return (Math.max(b[2], a[2]) - Math.min(b[0], a[0])) *\n           (Math.max(b[3], a[3]) - Math.min(b[1], a[1]));\n}\n\nfunction intersectionArea(a, b) {\n    var minX = Math.max(a[0], b[0]),\n        minY = Math.max(a[1], b[1]),\n        maxX = Math.min(a[2], b[2]),\n        maxY = Math.min(a[3], b[3]);\n\n    return Math.max(0, maxX - minX) *\n           Math.max(0, maxY - minY);\n}\n\nfunction contains(a, b) {\n    return a[0] <= b[0] &&\n           a[1] <= b[1] &&\n           b[2] <= a[2] &&\n           b[3] <= a[3];\n}\n\nfunction intersects(a, b) {\n    return b[0] <= a[2] &&\n           b[1] <= a[3] &&\n           b[2] >= a[0] &&\n           b[3] >= a[1];\n}\n\n// sort an array so that items come in groups of n unsorted items, with groups sorted between each other;\n// combines selection algorithm with binary divide & conquer approach\n\nfunction multiSelect(arr, left, right, n, compare) {\n    var stack = [left, right],\n        mid;\n\n    while (stack.length) {\n        right = stack.pop();\n        left = stack.pop();\n\n        if (right - left <= n) continue;\n\n        mid = left + Math.ceil((right - left) / n / 2) * n;\n        select(arr, left, right, mid, compare);\n\n        stack.push(left, mid, mid, right);\n    }\n}\n\n// Floyd-Rivest selection algorithm:\n// sort an array between left and right (inclusive) so that the smallest k elements come first (unordered)\nfunction select(arr, left, right, k, compare) {\n    var n, i, z, s, sd, newLeft, newRight, t, j;\n\n    while (right > left) {\n        if (right - left > 600) {\n            n = right - left + 1;\n            i = k - left + 1;\n            z = Math.log(n);\n            s = 0.5 * Math.exp(2 * z / 3);\n            sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (i - n / 2 < 0 ? -1 : 1);\n            newLeft = Math.max(left, Math.floor(k - i * s / n + sd));\n            newRight = Math.min(right, Math.floor(k + (n - i) * s / n + sd));\n            select(arr, newLeft, newRight, k, compare);\n        }\n\n        t = arr[k];\n        i = left;\n        j = right;\n\n        swap(arr, left, k);\n        if (compare(arr[right], t) > 0) swap(arr, left, right);\n\n        while (i < j) {\n            swap(arr, i, j);\n            i++;\n            j--;\n            while (compare(arr[i], t) < 0) i++;\n            while (compare(arr[j], t) > 0) j--;\n        }\n\n        if (compare(arr[left], t) === 0) swap(arr, left, j);\n        else {\n            j++;\n            swap(arr, j, right);\n        }\n\n        if (j <= k) left = j + 1;\n        if (k <= j) right = j - 1;\n    }\n}\n\nfunction swap(arr, i, j) {\n    var tmp = arr[i];\n    arr[i] = arr[j];\n    arr[j] = tmp;\n}\n\n\n// export as AMD/CommonJS module or global variable\nif (typeof define === 'function' && define.amd) define('rbush', function () { return rbush; });\nelse if (typeof module !== 'undefined') module.exports = rbush;\nelse if (typeof self !== 'undefined') self.rbush = rbush;\nelse window.rbush = rbush;\n\n})();\n"],"names":["module","exports","condition","format","a","b","c","d","e","f","error","undefined","args","argIndex","replace","name","framesToPop","_slicedToArray","arr","i","Array","isArray","Symbol","iterator","Object","sliceIterator","_arr","_n","_d","_e","_s","_i","next","done","push","value","length","err","_extends","assign","target","arguments","source","key","prototype","hasOwnProperty","call","_invariant2","_interopRequireDefault","__webpack_require__","_latLng","_createTree2","obj","__esModule","default","_toConsumableArray","from","arr2","createCluster","x","y","points","wx","wy","zoom","Infinity","numPoints","SuperCluster","options","_initTrees","minZoom","maxZoom","radius","extent","nodeSize","load","clusters","map","_ref","pt","_objectWithoutProperties","keys","indexOf","lat","lng","z","trees","_cluster","getClusters","bbox","_this","_bbox","nwLng","seLat","seLng","nwLat","Math","max","min","bBoxes","bBox","search","reduce","r","lst","concat","screenDist2LatLngDist","p","clusterPoints","bboxNeighbors","foundNeighbors","j","distSq","dx","dy","cluster","Z","cl","_ref2","_ref2$bounds","bounds","nw","se","defineProperty","_rbush2","toBBox","compareMinX","compareMinY","tree","lngX","latY","sin","PI","log","dist","distW","pow","__WEBPACK_AMD_DEFINE_RESULT__","rbush","maxEntries","_maxEntries","_minEntries","ceil","_initFormat","clear","calcBBox","node","distBBox","children","k","child","empty","extend","leaf","compareNodeMinX","compareNodeMinY","bboxArea","bboxMargin","contains","intersects","multiSelect","left","right","n","compare","mid","stack","pop","select","s","sd","t","exp","sqrt","floor","swap","tmp","all","_all","data","result","len","childBBox","nodesToSearch","collides","insert","_build","slice","height","_splitRoot","tmpNode","_insert","item","remove","parent","index","goingUp","path","indexes","splice","_condense","toJSON","fromJSON","apply","items","N","M","right2","right3","N2","N1","_chooseSubtree","level","targetNode","area","enlargement","minArea","minEnlargement","isNode","insertPath","_split","_adjustParentBBoxes","m","_chooseSplitAxis","splitIndex","_chooseSplitIndex","newNode","bbox1","bbox2","overlap","minOverlap","intersectionArea","minX","minY","maxX","maxY","_allDistMargin","sort","leftBBox","rightBBox","margin","siblings","compareArr","join"],"sourceRoot":""}