geojs 1.10.18 → 1.10.19

package/geo.js

@@ -22586,7 +22586,7 @@ var markerFeature = function markerFeature(arg) {
   var $ = __webpack_require__(5638);
   var timestamp = __webpack_require__(6618);
   var util = __webpack_require__(4634);
-  var KDBush = __webpack_require__(379);
+  var KDBush = __webpack_require__(5866);
   KDBush = KDBush.__esModule ? KDBush.default : KDBush;
 
   /**
@@ -24943,7 +24943,7 @@ var pointFeature = function pointFeature(arg) {
   var ClusterGroup = __webpack_require__(9808);
   var geo_event = __webpack_require__(5108);
   var util = __webpack_require__(4634);
-  var KDBush = __webpack_require__(379);
+  var KDBush = __webpack_require__(5866);
   KDBush = KDBush.__esModule ? KDBush.default : KDBush;
 
   /**
@@ -28079,7 +28079,7 @@ module.exports = sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "0539eada54b7f6ea9a63f07e3526680cebc61e30";
+module.exports = "27f3b67c529425dab8dc95621608e32b848d9c27";
 
 /***/ }),
 
@@ -39957,7 +39957,7 @@ module.exports = vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.10.18";
+module.exports = "1.10.19";
 
 /***/ }),
 
@@ -94408,6 +94408,361 @@ module.exports = "data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJo
 
 /***/ }),
 
+/***/ 5866:
+/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": function() { return /* binding */ KDBush; }
+/* harmony export */ });
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var ARRAY_TYPES = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+
+/** @typedef {Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor} TypedArrayConstructor */
+
+var VERSION = 1; // serialized format version
+var HEADER_SIZE = 8;
+var KDBush = /*#__PURE__*/function () {
+  /**
+   * Creates an index that will hold a given number of items.
+   * @param {number} numItems
+   * @param {number} [nodeSize=64] Size of the KD-tree node (64 by default).
+   * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+   * @param {ArrayBuffer} [data] (For internal use only)
+   */
+  function KDBush(numItems) {
+    var nodeSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 64;
+    var ArrayType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Float64Array;
+    var data = arguments.length > 3 ? arguments[3] : undefined;
+    _classCallCheck(this, KDBush);
+    if (isNaN(numItems) || numItems < 0) throw new Error("Unpexpected numItems value: ".concat(numItems, "."));
+    this.numItems = +numItems;
+    this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
+    this.ArrayType = ArrayType;
+    this.IndexArrayType = numItems < 65536 ? Uint16Array : Uint32Array;
+    var arrayTypeIndex = ARRAY_TYPES.indexOf(this.ArrayType);
+    var coordsByteSize = numItems * 2 * this.ArrayType.BYTES_PER_ELEMENT;
+    var idsByteSize = numItems * this.IndexArrayType.BYTES_PER_ELEMENT;
+    var padCoords = (8 - idsByteSize % 8) % 8;
+    if (arrayTypeIndex < 0) {
+      throw new Error("Unexpected typed array class: ".concat(ArrayType, "."));
+    }
+    if (data && data instanceof ArrayBuffer) {
+      // reconstruct an index from a buffer
+      this.data = data;
+      this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
+      this.coords = new this.ArrayType(this.data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
+      this._pos = numItems * 2;
+      this._finished = true;
+    } else {
+      // initialize a new index
+      this.data = new ArrayBuffer(HEADER_SIZE + coordsByteSize + idsByteSize + padCoords);
+      this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
+      this.coords = new this.ArrayType(this.data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
+      this._pos = 0;
+      this._finished = false;
+
+      // set header
+      new Uint8Array(this.data, 0, 2).set([0xdb, (VERSION << 4) + arrayTypeIndex]);
+      new Uint16Array(this.data, 2, 1)[0] = nodeSize;
+      new Uint32Array(this.data, 4, 1)[0] = numItems;
+    }
+  }
+
+  /**
+   * Add a point to the index.
+   * @param {number} x
+   * @param {number} y
+   * @returns {number} An incremental index associated with the added item (starting from `0`).
+   */
+  _createClass(KDBush, [{
+    key: "add",
+    value: function add(x, y) {
+      var index = this._pos >> 1;
+      this.ids[index] = index;
+      this.coords[this._pos++] = x;
+      this.coords[this._pos++] = y;
+      return index;
+    }
+
+    /**
+     * Perform indexing of the added points.
+     */
+  }, {
+    key: "finish",
+    value: function finish() {
+      var numAdded = this._pos >> 1;
+      if (numAdded !== this.numItems) {
+        throw new Error("Added ".concat(numAdded, " items when expected ").concat(this.numItems, "."));
+      }
+      // kd-sort both arrays for efficient search
+      sort(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0);
+      this._finished = true;
+      return this;
+    }
+
+    /**
+     * Search the index for items within a given bounding box.
+     * @param {number} minX
+     * @param {number} minY
+     * @param {number} maxX
+     * @param {number} maxY
+     * @returns {number[]} An array of indices correponding to the found items.
+     */
+  }, {
+    key: "range",
+    value: function range(minX, minY, maxX, maxY) {
+      if (!this._finished) throw new Error('Data not yet indexed - call index.finish().');
+      var ids = this.ids,
+        coords = this.coords,
+        nodeSize = this.nodeSize;
+      var stack = [0, ids.length - 1, 0];
+      var result = [];
+
+      // recursively search for items in range in the kd-sorted arrays
+      while (stack.length) {
+        var axis = stack.pop() || 0;
+        var right = stack.pop() || 0;
+        var left = stack.pop() || 0;
+
+        // if we reached "tree node", search linearly
+        if (right - left <= nodeSize) {
+          for (var i = left; i <= right; i++) {
+            var _x = coords[2 * i];
+            var _y = coords[2 * i + 1];
+            if (_x >= minX && _x <= maxX && _y >= minY && _y <= maxY) result.push(ids[i]);
+          }
+          continue;
+        }
+
+        // otherwise find the middle index
+        var m = left + right >> 1;
+
+        // include the middle item if it's in range
+        var x = coords[2 * m];
+        var y = coords[2 * m + 1];
+        if (x >= minX && x <= maxX && y >= minY && y <= maxY) result.push(ids[m]);
+
+        // queue search in halves that intersect the query
+        if (axis === 0 ? minX <= x : minY <= y) {
+          stack.push(left);
+          stack.push(m - 1);
+          stack.push(1 - axis);
+        }
+        if (axis === 0 ? maxX >= x : maxY >= y) {
+          stack.push(m + 1);
+          stack.push(right);
+          stack.push(1 - axis);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Search the index for items within a given radius.
+     * @param {number} qx
+     * @param {number} qy
+     * @param {number} r Query radius.
+     * @returns {number[]} An array of indices correponding to the found items.
+     */
+  }, {
+    key: "within",
+    value: function within(qx, qy, r) {
+      if (!this._finished) throw new Error('Data not yet indexed - call index.finish().');
+      var ids = this.ids,
+        coords = this.coords,
+        nodeSize = this.nodeSize;
+      var stack = [0, ids.length - 1, 0];
+      var result = [];
+      var r2 = r * r;
+
+      // recursively search for items within radius in the kd-sorted arrays
+      while (stack.length) {
+        var axis = stack.pop() || 0;
+        var right = stack.pop() || 0;
+        var left = stack.pop() || 0;
+
+        // if we reached "tree node", search linearly
+        if (right - left <= nodeSize) {
+          for (var i = left; i <= right; i++) {
+            if (sqDist(coords[2 * i], coords[2 * i + 1], qx, qy) <= r2) result.push(ids[i]);
+          }
+          continue;
+        }
+
+        // otherwise find the middle index
+        var m = left + right >> 1;
+
+        // include the middle item if it's in range
+        var x = coords[2 * m];
+        var y = coords[2 * m + 1];
+        if (sqDist(x, y, qx, qy) <= r2) result.push(ids[m]);
+
+        // queue search in halves that intersect the query
+        if (axis === 0 ? qx - r <= x : qy - r <= y) {
+          stack.push(left);
+          stack.push(m - 1);
+          stack.push(1 - axis);
+        }
+        if (axis === 0 ? qx + r >= x : qy + r >= y) {
+          stack.push(m + 1);
+          stack.push(right);
+          stack.push(1 - axis);
+        }
+      }
+      return result;
+    }
+  }], [{
+    key: "from",
+    value:
+    /**
+     * Creates an index from raw `ArrayBuffer` data.
+     * @param {ArrayBuffer} data
+     */
+    function from(data) {
+      if (!(data instanceof ArrayBuffer)) {
+        throw new Error('Data must be an instance of ArrayBuffer.');
+      }
+      var _Uint8Array = new Uint8Array(data, 0, 2),
+        _Uint8Array2 = _slicedToArray(_Uint8Array, 2),
+        magic = _Uint8Array2[0],
+        versionAndType = _Uint8Array2[1];
+      if (magic !== 0xdb) {
+        throw new Error('Data does not appear to be in a KDBush format.');
+      }
+      var version = versionAndType >> 4;
+      if (version !== VERSION) {
+        throw new Error("Got v".concat(version, " data when expected v").concat(VERSION, "."));
+      }
+      var ArrayType = ARRAY_TYPES[versionAndType & 0x0f];
+      if (!ArrayType) {
+        throw new Error('Unrecognized array type.');
+      }
+      var _Uint16Array = new Uint16Array(data, 2, 1),
+        _Uint16Array2 = _slicedToArray(_Uint16Array, 1),
+        nodeSize = _Uint16Array2[0];
+      var _Uint32Array = new Uint32Array(data, 4, 1),
+        _Uint32Array2 = _slicedToArray(_Uint32Array, 1),
+        numItems = _Uint32Array2[0];
+      return new KDBush(numItems, nodeSize, ArrayType, data);
+    }
+  }]);
+  return KDBush;
+}();
+/**
+ * @param {Uint16Array | Uint32Array} ids
+ * @param {InstanceType<TypedArrayConstructor>} coords
+ * @param {number} nodeSize
+ * @param {number} left
+ * @param {number} right
+ * @param {number} axis
+ */
+
+function sort(ids, coords, nodeSize, left, right, axis) {
+  if (right - left <= nodeSize) return;
+  var m = left + right >> 1; // middle index
+
+  // sort ids and coords around the middle index so that the halves lie
+  // either left/right or top/bottom correspondingly (taking turns)
+  select(ids, coords, m, left, right, axis);
+
+  // recursively kd-sort first half and second half on the opposite axis
+  sort(ids, coords, nodeSize, left, m - 1, 1 - axis);
+  sort(ids, coords, nodeSize, m + 1, right, 1 - axis);
+}
+
+/**
+ * Custom Floyd-Rivest selection algorithm: sort ids and coords so that
+ * [left..k-1] items are smaller than k-th item (on either x or y axis)
+ * @param {Uint16Array | Uint32Array} ids
+ * @param {InstanceType<TypedArrayConstructor>} coords
+ * @param {number} k
+ * @param {number} left
+ * @param {number} right
+ * @param {number} axis
+ */
+function select(ids, coords, k, left, right, axis) {
+  while (right > left) {
+    if (right - left > 600) {
+      var n = right - left + 1;
+      var m = k - left + 1;
+      var z = Math.log(n);
+      var s = 0.5 * Math.exp(2 * z / 3);
+      var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+      var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
+      var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
+      select(ids, coords, k, newLeft, newRight, axis);
+    }
+    var t = coords[2 * k + axis];
+    var i = left;
+    var j = right;
+    swapItem(ids, coords, left, k);
+    if (coords[2 * right + axis] > t) swapItem(ids, coords, left, right);
+    while (i < j) {
+      swapItem(ids, coords, i, j);
+      i++;
+      j--;
+      while (coords[2 * i + axis] < t) i++;
+      while (coords[2 * j + axis] > t) j--;
+    }
+    if (coords[2 * left + axis] === t) swapItem(ids, coords, left, j);else {
+      j++;
+      swapItem(ids, coords, j, right);
+    }
+    if (j <= k) left = j + 1;
+    if (k <= j) right = j - 1;
+  }
+}
+
+/**
+ * @param {Uint16Array | Uint32Array} ids
+ * @param {InstanceType<TypedArrayConstructor>} coords
+ * @param {number} i
+ * @param {number} j
+ */
+function swapItem(ids, coords, i, j) {
+  swap(ids, i, j);
+  swap(coords, 2 * i, 2 * j);
+  swap(coords, 2 * i + 1, 2 * j + 1);
+}
+
+/**
+ * @param {InstanceType<TypedArrayConstructor>} arr
+ * @param {number} i
+ * @param {number} j
+ */
+function swap(arr, i, j) {
+  var tmp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = tmp;
+}
+
+/**
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} bx
+ * @param {number} by
+ */
+function sqDist(ax, ay, bx, by) {
+  var dx = ax - bx;
+  var dy = ay - by;
+  return dx * dx + dy * dy;
+}
+
+/***/ }),
+
 /***/ 1485:
 /***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
@@ -94565,345 +94920,6 @@ __webpack_require__.r(__webpack_exports__);
 });
 
 
-/***/ }),
-
-/***/ 379:
-/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "default": function() { return /* binding */ KDBush; }
-/* harmony export */ });
-
-const ARRAY_TYPES = [
-    Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array,
-    Int32Array, Uint32Array, Float32Array, Float64Array
-];
-
-/** @typedef {Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor} TypedArrayConstructor */
-
-const VERSION = 1; // serialized format version
-const HEADER_SIZE = 8;
-
-class KDBush {
-
-    /**
-     * Creates an index from raw `ArrayBuffer` data.
-     * @param {ArrayBuffer} data
-     */
-    static from(data) {
-        if (!(data instanceof ArrayBuffer)) {
-            throw new Error('Data must be an instance of ArrayBuffer.');
-        }
-        const [magic, versionAndType] = new Uint8Array(data, 0, 2);
-        if (magic !== 0xdb) {
-            throw new Error('Data does not appear to be in a KDBush format.');
-        }
-        const version = versionAndType >> 4;
-        if (version !== VERSION) {
-            throw new Error(`Got v${version} data when expected v${VERSION}.`);
-        }
-        const ArrayType = ARRAY_TYPES[versionAndType & 0x0f];
-        if (!ArrayType) {
-            throw new Error('Unrecognized array type.');
-        }
-        const [nodeSize] = new Uint16Array(data, 2, 1);
-        const [numItems] = new Uint32Array(data, 4, 1);
-
-        return new KDBush(numItems, nodeSize, ArrayType, data);
-    }
-
-    /**
-     * Creates an index that will hold a given number of items.
-     * @param {number} numItems
-     * @param {number} [nodeSize=64] Size of the KD-tree node (64 by default).
-     * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
-     * @param {ArrayBuffer} [data] (For internal use only)
-     */
-    constructor(numItems, nodeSize = 64, ArrayType = Float64Array, data) {
-        if (isNaN(numItems) || numItems < 0) throw new Error(`Unpexpected numItems value: ${numItems}.`);
-
-        this.numItems = +numItems;
-        this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
-        this.ArrayType = ArrayType;
-        this.IndexArrayType = numItems < 65536 ? Uint16Array : Uint32Array;
-
-        const arrayTypeIndex = ARRAY_TYPES.indexOf(this.ArrayType);
-        const coordsByteSize = numItems * 2 * this.ArrayType.BYTES_PER_ELEMENT;
-        const idsByteSize = numItems * this.IndexArrayType.BYTES_PER_ELEMENT;
-        const padCoords = (8 - idsByteSize % 8) % 8;
-
-        if (arrayTypeIndex < 0) {
-            throw new Error(`Unexpected typed array class: ${ArrayType}.`);
-        }
-
-        if (data && (data instanceof ArrayBuffer)) { // reconstruct an index from a buffer
-            this.data = data;
-            this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
-            this.coords = new this.ArrayType(this.data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
-            this._pos = numItems * 2;
-            this._finished = true;
-        } else { // initialize a new index
-            this.data = new ArrayBuffer(HEADER_SIZE + coordsByteSize + idsByteSize + padCoords);
-            this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
-            this.coords = new this.ArrayType(this.data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
-            this._pos = 0;
-            this._finished = false;
-
-            // set header
-            new Uint8Array(this.data, 0, 2).set([0xdb, (VERSION << 4) + arrayTypeIndex]);
-            new Uint16Array(this.data, 2, 1)[0] = nodeSize;
-            new Uint32Array(this.data, 4, 1)[0] = numItems;
-        }
-    }
-
-    /**
-     * Add a point to the index.
-     * @param {number} x
-     * @param {number} y
-     * @returns {number} An incremental index associated with the added item (starting from `0`).
-     */
-    add(x, y) {
-        const index = this._pos >> 1;
-        this.ids[index] = index;
-        this.coords[this._pos++] = x;
-        this.coords[this._pos++] = y;
-        return index;
-    }
-
-    /**
-     * Perform indexing of the added points.
-     */
-    finish() {
-        const numAdded = this._pos >> 1;
-        if (numAdded !== this.numItems) {
-            throw new Error(`Added ${numAdded} items when expected ${this.numItems}.`);
-        }
-        // kd-sort both arrays for efficient search
-        sort(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0);
-
-        this._finished = true;
-        return this;
-    }
-
-    /**
-     * Search the index for items within a given bounding box.
-     * @param {number} minX
-     * @param {number} minY
-     * @param {number} maxX
-     * @param {number} maxY
-     * @returns {number[]} An array of indices correponding to the found items.
-     */
-    range(minX, minY, maxX, maxY) {
-        if (!this._finished) throw new Error('Data not yet indexed - call index.finish().');
-
-        const {ids, coords, nodeSize} = this;
-        const stack = [0, ids.length - 1, 0];
-        const result = [];
-
-        // recursively search for items in range in the kd-sorted arrays
-        while (stack.length) {
-            const axis = stack.pop() || 0;
-            const right = stack.pop() || 0;
-            const left = stack.pop() || 0;
-
-            // if we reached "tree node", search linearly
-            if (right - left <= nodeSize) {
-                for (let i = left; i <= right; i++) {
-                    const x = coords[2 * i];
-                    const y = coords[2 * i + 1];
-                    if (x >= minX && x <= maxX && y >= minY && y <= maxY) result.push(ids[i]);
-                }
-                continue;
-            }
-
-            // otherwise find the middle index
-            const m = (left + right) >> 1;
-
-            // include the middle item if it's in range
-            const x = coords[2 * m];
-            const y = coords[2 * m + 1];
-            if (x >= minX && x <= maxX && y >= minY && y <= maxY) result.push(ids[m]);
-
-            // queue search in halves that intersect the query
-            if (axis === 0 ? minX <= x : minY <= y) {
-                stack.push(left);
-                stack.push(m - 1);
-                stack.push(1 - axis);
-            }
-            if (axis === 0 ? maxX >= x : maxY >= y) {
-                stack.push(m + 1);
-                stack.push(right);
-                stack.push(1 - axis);
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * Search the index for items within a given radius.
-     * @param {number} qx
-     * @param {number} qy
-     * @param {number} r Query radius.
-     * @returns {number[]} An array of indices correponding to the found items.
-     */
-    within(qx, qy, r) {
-        if (!this._finished) throw new Error('Data not yet indexed - call index.finish().');
-
-        const {ids, coords, nodeSize} = this;
-        const stack = [0, ids.length - 1, 0];
-        const result = [];
-        const r2 = r * r;
-
-        // recursively search for items within radius in the kd-sorted arrays
-        while (stack.length) {
-            const axis = stack.pop() || 0;
-            const right = stack.pop() || 0;
-            const left = stack.pop() || 0;
-
-            // if we reached "tree node", search linearly
-            if (right - left <= nodeSize) {
-                for (let i = left; i <= right; i++) {
-                    if (sqDist(coords[2 * i], coords[2 * i + 1], qx, qy) <= r2) result.push(ids[i]);
-                }
-                continue;
-            }
-
-            // otherwise find the middle index
-            const m = (left + right) >> 1;
-
-            // include the middle item if it's in range
-            const x = coords[2 * m];
-            const y = coords[2 * m + 1];
-            if (sqDist(x, y, qx, qy) <= r2) result.push(ids[m]);
-
-            // queue search in halves that intersect the query
-            if (axis === 0 ? qx - r <= x : qy - r <= y) {
-                stack.push(left);
-                stack.push(m - 1);
-                stack.push(1 - axis);
-            }
-            if (axis === 0 ? qx + r >= x : qy + r >= y) {
-                stack.push(m + 1);
-                stack.push(right);
-                stack.push(1 - axis);
-            }
-        }
-
-        return result;
-    }
-}
-
-/**
- * @param {Uint16Array | Uint32Array} ids
- * @param {InstanceType<TypedArrayConstructor>} coords
- * @param {number} nodeSize
- * @param {number} left
- * @param {number} right
- * @param {number} axis
- */
-function sort(ids, coords, nodeSize, left, right, axis) {
-    if (right - left <= nodeSize) return;
-
-    const m = (left + right) >> 1; // middle index
-
-    // sort ids and coords around the middle index so that the halves lie
-    // either left/right or top/bottom correspondingly (taking turns)
-    select(ids, coords, m, left, right, axis);
-
-    // recursively kd-sort first half and second half on the opposite axis
-    sort(ids, coords, nodeSize, left, m - 1, 1 - axis);
-    sort(ids, coords, nodeSize, m + 1, right, 1 - axis);
-}
-
-/**
- * Custom Floyd-Rivest selection algorithm: sort ids and coords so that
- * [left..k-1] items are smaller than k-th item (on either x or y axis)
- * @param {Uint16Array | Uint32Array} ids
- * @param {InstanceType<TypedArrayConstructor>} coords
- * @param {number} k
- * @param {number} left
- * @param {number} right
- * @param {number} axis
- */
-function select(ids, coords, k, left, right, axis) {
-
-    while (right > left) {
-        if (right - left > 600) {
-            const n = right - left + 1;
-            const m = k - left + 1;
-            const z = Math.log(n);
-            const s = 0.5 * Math.exp(2 * z / 3);
-            const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
-            const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
-            const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
-            select(ids, coords, k, newLeft, newRight, axis);
-        }
-
-        const t = coords[2 * k + axis];
-        let i = left;
-        let j = right;
-
-        swapItem(ids, coords, left, k);
-        if (coords[2 * right + axis] > t) swapItem(ids, coords, left, right);
-
-        while (i < j) {
-            swapItem(ids, coords, i, j);
-            i++;
-            j--;
-            while (coords[2 * i + axis] < t) i++;
-            while (coords[2 * j + axis] > t) j--;
-        }
-
-        if (coords[2 * left + axis] === t) swapItem(ids, coords, left, j);
-        else {
-            j++;
-            swapItem(ids, coords, j, right);
-        }
-
-        if (j <= k) left = j + 1;
-        if (k <= j) right = j - 1;
-    }
-}
-
-/**
- * @param {Uint16Array | Uint32Array} ids
- * @param {InstanceType<TypedArrayConstructor>} coords
- * @param {number} i
- * @param {number} j
- */
-function swapItem(ids, coords, i, j) {
-    swap(ids, i, j);
-    swap(coords, 2 * i, 2 * j);
-    swap(coords, 2 * i + 1, 2 * j + 1);
-}
-
-/**
- * @param {InstanceType<TypedArrayConstructor>} arr
- * @param {number} i
- * @param {number} j
- */
-function swap(arr, i, j) {
-    const tmp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = tmp;
-}
-
-/**
- * @param {number} ax
- * @param {number} ay
- * @param {number} bx
- * @param {number} by
- */
-function sqDist(ax, ay, bx, by) {
-    const dx = ax - bx;
-    const dy = ay - by;
-    return dx * dx + dy * dy;
-}
-
-
 /***/ })
 
 /******/ 	});