node-red-contrib-tak-registration 0.3.1 → 0.6.0

package/node_modules/rbush/rbush.js

@@ -1,475 +1,467 @@
-(function (global, factory) {
-typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-typeof define === 'function' && define.amd ? define(factory) :
-(global = global || self, global.RBush = factory());
-}(this, function () { 'use strict';
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.rbush = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+'use strict';
 
-function quickselect(arr, k, left, right, compare) {
-    quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare);
-}
-
-function quickselectStep(arr, k, left, right, compare) {
-
-    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));
-            quickselectStep(arr, k, newLeft, newRight, compare);
-        }
-
-        var t = arr[k];
-        var i = left;
-        var j = right;
+module.exports = rbush;
+module.exports.default = rbush;
 
-        swap(arr, left, k);
-        if (compare(arr[right], t) > 0) { swap(arr, left, right); }
+var quickselect = require('quickselect');
 
-        while (i < j) {
-            swap(arr, i, j);
-            i++;
-            j--;
-            while (compare(arr[i], t) < 0) { i++; }
-            while (compare(arr[j], t) > 0) { j--; }
-        }
+function rbush(maxEntries, format) {
+    if (!(this instanceof rbush)) return new rbush(maxEntries, format);
 
-        if (compare(arr[left], t) === 0) { swap(arr, left, j); }
-        else {
-            j++;
-            swap(arr, j, right);
-        }
+    // max entries in a node is 9 by default; min node fill is 40% for best performance
+    this._maxEntries = Math.max(4, maxEntries || 9);
+    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
 
-        if (j <= k) { left = j + 1; }
-        if (k <= j) { right = j - 1; }
+    if (format) {
+        this._initFormat(format);
     }
-}
 
-function swap(arr, i, j) {
-    var tmp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = tmp;
+    this.clear();
 }
 
-function defaultCompare(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
+rbush.prototype = {
 
-var RBush = function RBush(maxEntries) {
-    if ( maxEntries === void 0 ) maxEntries = 9;
+    all: function () {
+        return this._all(this.data, []);
+    },
 
-    // max entries in a node is 9 by default; min node fill is 40% for best performance
-    this._maxEntries = Math.max(4, maxEntries);
-    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
-    this.clear();
-};
+    search: function (bbox) {
 
-RBush.prototype.all = function all () {
-    return this._all(this.data, []);
-};
+        var node = this.data,
+            result = [],
+            toBBox = this.toBBox;
 
-RBush.prototype.search = function search (bbox) {
-    var node = this.data;
-    var result = [];
+        if (!intersects(bbox, node)) return result;
 
-    if (!intersects(bbox, node)) { return result; }
+        var nodesToSearch = [],
+            i, len, child, childBBox;
 
-    var toBBox = this.toBBox;
-    var nodesToSearch = [];
+        while (node) {
+            for (i = 0, len = node.children.length; i < len; i++) {
 
-    while (node) {
-        for (var i = 0; i < node.children.length; i++) {
-            var child = node.children[i];
-            var childBBox = node.leaf ? toBBox(child) : child;
+                child = node.children[i];
+                childBBox = node.leaf ? toBBox(child) : child;
 
-            if (intersects(bbox, childBBox)) {
-                if (node.leaf) { result.push(child); }
-                else if (contains(bbox, childBBox)) { this._all(child, result); }
-                else { nodesToSearch.push(child); }
+                if (intersects(bbox, childBBox)) {
+                    if (node.leaf) result.push(child);
+                    else if (contains(bbox, childBBox)) this._all(child, result);
+                    else nodesToSearch.push(child);
+                }
             }
+            node = nodesToSearch.pop();
         }
-        node = nodesToSearch.pop();
-    }
 
-    return result;
-};
+        return result;
+    },
+
+    collides: function (bbox) {
 
-RBush.prototype.collides = function collides (bbox) {
-    var node = this.data;
+        var node = this.data,
+            toBBox = this.toBBox;
 
-    if (!intersects(bbox, node)) { return false; }
+        if (!intersects(bbox, node)) return false;
 
-    var nodesToSearch = [];
-    while (node) {
-        for (var i = 0; i < node.children.length; i++) {
-            var child = node.children[i];
-            var childBBox = node.leaf ? this.toBBox(child) : child;
+        var nodesToSearch = [],
+            i, len, child, childBBox;
 
-            if (intersects(bbox, childBBox)) {
-                if (node.leaf || contains(bbox, childBBox)) { return true; }
-                nodesToSearch.push(child);
+        while (node) {
+            for (i = 0, len = node.children.length; i < len; i++) {
+
+                child = node.children[i];
+                childBBox = node.leaf ? toBBox(child) : child;
+
+                if (intersects(bbox, childBBox)) {
+                    if (node.leaf || contains(bbox, childBBox)) return true;
+                    nodesToSearch.push(child);
+                }
             }
+            node = nodesToSearch.pop();
         }
-        node = nodesToSearch.pop();
-    }
 
-    return false;
-};
+        return false;
+    },
 
-RBush.prototype.load = function load (data) {
-    if (!(data && data.length)) { return this; }
+    load: function (data) {
+        if (!(data && data.length)) return this;
 
-    if (data.length < this._minEntries) {
-        for (var i = 0; i < data.length; i++) {
-            this.insert(data[i]);
+        if (data.length < this._minEntries) {
+            for (var i = 0, len = data.length; i < len; i++) {
+                this.insert(data[i]);
+            }
+            return this;
         }
-        return this;
-    }
 
-    // recursively build the tree with the given data from scratch using OMT algorithm
-    var node = this._build(data.slice(), 0, data.length - 1, 0);
+        // recursively build the tree with the given data from scratch using OMT algorithm
+        var node = this._build(data.slice(), 0, data.length - 1, 0);
+
+        if (!this.data.children.length) {
+            // save as is if tree is empty
+            this.data = node;
 
-    if (!this.data.children.length) {
-        // save as is if tree is empty
-        this.data = node;
+        } else if (this.data.height === node.height) {
+            // split root if trees have the same height
+            this._splitRoot(this.data, node);
 
-    } else if (this.data.height === node.height) {
-        // split root if trees have the same height
-        this._splitRoot(this.data, node);
+        } else {
+            if (this.data.height < node.height) {
+                // swap trees if inserted one is bigger
+                var tmpNode = this.data;
+                this.data = node;
+                node = tmpNode;
+            }
 
-    } else {
-        if (this.data.height < node.height) {
-            // swap trees if inserted one is bigger
-            var tmpNode = this.data;
-            this.data = node;
-            node = tmpNode;
+            // insert the small tree into the large tree at appropriate level
+            this._insert(node, this.data.height - node.height - 1, true);
         }
 
-        // insert the small tree into the large tree at appropriate level
-        this._insert(node, this.data.height - node.height - 1, true);
-    }
-
-    return this;
-};
+        return this;
+    },
 
-RBush.prototype.insert = function insert (item) {
-    if (item) { this._insert(item, this.data.height - 1); }
-    return this;
-};
+    insert: function (item) {
+        if (item) this._insert(item, this.data.height - 1);
+        return this;
+    },
 
-RBush.prototype.clear = function clear () {
-    this.data = createNode([]);
-    return this;
-};
+    clear: function () {
+        this.data = createNode([]);
+        return this;
+    },
 
-RBush.prototype.remove = function remove (item, equalsFn) {
-    if (!item) { return this; }
+    remove: function (item, equalsFn) {
+        if (!item) return this;
 
-    var node = this.data;
-    var bbox = this.toBBox(item);
-    var path = [];
-    var indexes = [];
-    var i, parent, goingUp;
+        var node = this.data,
+            bbox = this.toBBox(item),
+            path = [],
+            indexes = [],
+            i, parent, index, goingUp;
 
-    // depth-first iterative tree traversal
-    while (node || path.length) {
+        // depth-first iterative tree traversal
+        while (node || path.length) {
 
-        if (!node) { // go up
-            node = path.pop();
-            parent = path[path.length - 1];
-            i = indexes.pop();
-            goingUp = true;
-        }
+            if (!node) { // go up
+                node = path.pop();
+                parent = path[path.length - 1];
+                i = indexes.pop();
+                goingUp = true;
+            }
 
-        if (node.leaf) { // check current node
-            var index = findItem(item, node.children, equalsFn);
+            if (node.leaf) { // check current node
+                index = findItem(item, node.children, equalsFn);
 
-            if (index !== -1) {
-                // item found, remove the item and condense tree upwards
-                node.children.splice(index, 1);
-                path.push(node);
-                this._condense(path);
-                return this;
+                if (index !== -1) {
+                    // item found, remove the item and condense tree upwards
+                    node.children.splice(index, 1);
+                    path.push(node);
+                    this._condense(path);
+                    return this;
+                }
             }
-        }
 
-        if (!goingUp && !node.leaf && contains(node, bbox)) { // go down
-            path.push(node);
-            indexes.push(i);
-            i = 0;
-            parent = node;
-            node = node.children[0];
+            if (!goingUp && !node.leaf && contains(node, bbox)) { // go down
+                path.push(node);
+                indexes.push(i);
+                i = 0;
+                parent = node;
+                node = node.children[0];
 
-        } else if (parent) { // go right
-            i++;
-            node = parent.children[i];
-            goingUp = false;
+            } else if (parent) { // go right
+                i++;
+                node = parent.children[i];
+                goingUp = false;
 
-        } else { node = null; } // nothing found
-    }
+            } else node = null; // nothing found
+        }
 
-    return this;
-};
+        return this;
+    },
 
-RBush.prototype.toBBox = function toBBox (item) { return item; };
+    toBBox: function (item) { return item; },
 
-RBush.prototype.compareMinX = function compareMinX (a, b) { return a.minX - b.minX; };
-RBush.prototype.compareMinY = function compareMinY (a, b) { return a.minY - b.minY; };
+    compareMinX: compareNodeMinX,
+    compareMinY: compareNodeMinY,
 
-RBush.prototype.toJSON = function toJSON () { return this.data; };
+    toJSON: function () { return this.data; },
 
-RBush.prototype.fromJSON = function fromJSON (data) {
-    this.data = data;
-    return this;
-};
+    fromJSON: function (data) {
+        this.data = data;
+        return this;
+    },
 
-RBush.prototype._all = function _all (node, result) {
-    var nodesToSearch = [];
-    while (node) {
-        if (node.leaf) { result.push.apply(result, node.children); }
-        else { nodesToSearch.push.apply(nodesToSearch, node.children); }
+    _all: function (node, result) {
+        var nodesToSearch = [];
+        while (node) {
+            if (node.leaf) result.push.apply(result, node.children);
+            else nodesToSearch.push.apply(nodesToSearch, node.children);
 
-        node = nodesToSearch.pop();
-    }
-    return result;
-};
+            node = nodesToSearch.pop();
+        }
+        return result;
+    },
 
-RBush.prototype._build = function _build (items, left, right, height) {
+    _build: function (items, left, right, height) {
 
-    var N = right - left + 1;
-    var M = this._maxEntries;
-    var node;
+        var N = right - left + 1,
+            M = this._maxEntries,
+            node;
 
-    if (N <= M) {
-        // reached leaf level; return leaf
-        node = createNode(items.slice(left, right + 1));
-        calcBBox(node, this.toBBox);
-        return node;
-    }
+        if (N <= M) {
+            // reached leaf level; return leaf
+            node = createNode(items.slice(left, right + 1));
+            calcBBox(node, this.toBBox);
+            return node;
+        }
 
-    if (!height) {
-        // target height of the bulk-loaded tree
-        height = Math.ceil(Math.log(N) / Math.log(M));
+        if (!height) {
+            // target height of the bulk-loaded tree
+            height = Math.ceil(Math.log(N) / Math.log(M));
 
-        // target number of root entries to maximize storage utilization
-        M = Math.ceil(N / Math.pow(M, height - 1));
-    }
+            // target number of root entries to maximize storage utilization
+            M = Math.ceil(N / Math.pow(M, height - 1));
+        }
 
-    node = createNode([]);
-    node.leaf = false;
-    node.height = height;
+        node = createNode([]);
+        node.leaf = false;
+        node.height = height;
 
-    // split the items into M mostly square tiles
+        // split the items into M mostly square tiles
 
-    var N2 = Math.ceil(N / M);
-    var N1 = N2 * Math.ceil(Math.sqrt(M));
+        var N2 = Math.ceil(N / M),
+            N1 = N2 * Math.ceil(Math.sqrt(M)),
+            i, j, right2, right3;
 
-    multiSelect(items, left, right, N1, this.compareMinX);
+        multiSelect(items, left, right, N1, this.compareMinX);
 
-    for (var i = left; i <= right; i += N1) {
+        for (i = left; i <= right; i += N1) {
 
-        var right2 = Math.min(i + N1 - 1, right);
+            right2 = Math.min(i + N1 - 1, right);
 
-        multiSelect(items, i, right2, N2, this.compareMinY);
+            multiSelect(items, i, right2, N2, this.compareMinY);
 
-        for (var j = i; j <= right2; j += N2) {
+            for (j = i; j <= right2; j += N2) {
 
-            var right3 = Math.min(j + N2 - 1, right2);
+                right3 = Math.min(j + N2 - 1, right2);
 
-            // pack each entry recursively
-            node.children.push(this._build(items, j, right3, height - 1));
+                // pack each entry recursively
+                node.children.push(this._build(items, j, right3, height - 1));
+            }
         }
-    }
 
-    calcBBox(node, this.toBBox);
+        calcBBox(node, this.toBBox);
 
-    return node;
-};
+        return node;
+    },
 
-RBush.prototype._chooseSubtree = function _chooseSubtree (bbox, node, level, path) {
-    while (true) {
-        path.push(node);
+    _chooseSubtree: function (bbox, node, level, path) {
 
-        if (node.leaf || path.length - 1 === level) { break; }
+        var i, len, child, targetNode, area, enlargement, minArea, minEnlargement;
 
-        var minArea = Infinity;
-        var minEnlargement = Infinity;
-        var targetNode = (void 0);
+        while (true) {
+            path.push(node);
 
-        for (var i = 0; i < node.children.length; i++) {
-            var child = node.children[i];
-            var area = bboxArea(child);
-            var enlargement = enlargedArea(bbox, child) - area;
+            if (node.leaf || path.length - 1 === level) break;
 
-            // choose entry with the least area enlargement
-            if (enlargement < minEnlargement) {
-                minEnlargement = enlargement;
-                minArea = area < minArea ? area : minArea;
-                targetNode = child;
+            minArea = minEnlargement = Infinity;
 
-            } else if (enlargement === minEnlargement) {
-                // otherwise choose one with the smallest area
-                if (area < minArea) {
-                    minArea = area;
+            for (i = 0, len = node.children.length; i < len; i++) {
+                child = node.children[i];
+                area = bboxArea(child);
+                enlargement = enlargedArea(bbox, child) - area;
+
+                // choose entry with the least area enlargement
+                if (enlargement < minEnlargement) {
+                    minEnlargement = enlargement;
+                    minArea = area < minArea ? area : minArea;
                     targetNode = child;
+
+                } else if (enlargement === minEnlargement) {
+                    // otherwise choose one with the smallest area
+                    if (area < minArea) {
+                        minArea = area;
+                        targetNode = child;
+                    }
                 }
             }
+
+            node = targetNode || node.children[0];
         }
 
-        node = targetNode || node.children[0];
-    }
+        return node;
+    },
 
-    return node;
-};
+    _insert: function (item, level, isNode) {
 
-RBush.prototype._insert = function _insert (item, level, isNode) {
-    var bbox = isNode ? item : this.toBBox(item);
-    var insertPath = [];
+        var toBBox = this.toBBox,
+            bbox = isNode ? item : toBBox(item),
+            insertPath = [];
 
-    // find the best node for accommodating the item, saving all nodes along the path too
-    var node = this._chooseSubtree(bbox, this.data, level, insertPath);
+        // find the best node for accommodating the item, saving all nodes along the path too
+        var node = this._chooseSubtree(bbox, this.data, level, insertPath);
 
-    // put the item into the node
-    node.children.push(item);
-    extend(node, bbox);
+        // put the item into the node
+        node.children.push(item);
+        extend(node, bbox);
 
-    // split on node overflow; propagate upwards if necessary
-    while (level >= 0) {
-        if (insertPath[level].children.length > this._maxEntries) {
-            this._split(insertPath, level);
-            level--;
-        } else { break; }
-    }
+        // split on node overflow; propagate upwards if necessary
+        while (level >= 0) {
+            if (insertPath[level].children.length > this._maxEntries) {
+                this._split(insertPath, level);
+                level--;
+            } else break;
+        }
 
-    // adjust bboxes along the insertion path
-    this._adjustParentBBoxes(bbox, insertPath, level);
-};
+        // adjust bboxes along the insertion path
+        this._adjustParentBBoxes(bbox, insertPath, level);
+    },
 
-// split overflowed node into two
-RBush.prototype._split = function _split (insertPath, level) {
-    var node = insertPath[level];
-    var M = node.children.length;
-    var m = this._minEntries;
+    // split overflowed node into two
+    _split: function (insertPath, level) {
 
-    this._chooseSplitAxis(node, m, M);
+        var node = insertPath[level],
+            M = node.children.length,
+            m = this._minEntries;
 
-    var splitIndex = this._chooseSplitIndex(node, m, M);
+        this._chooseSplitAxis(node, m, M);
 
-    var newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
-    newNode.height = node.height;
-    newNode.leaf = node.leaf;
+        var splitIndex = this._chooseSplitIndex(node, m, M);
 
-    calcBBox(node, this.toBBox);
-    calcBBox(newNode, this.toBBox);
+        var newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
+        newNode.height = node.height;
+        newNode.leaf = node.leaf;
 
-    if (level) { insertPath[level - 1].children.push(newNode); }
-    else { this._splitRoot(node, newNode); }
-};
+        calcBBox(node, this.toBBox);
+        calcBBox(newNode, this.toBBox);
 
-RBush.prototype._splitRoot = function _splitRoot (node, newNode) {
-    // split root node
-    this.data = createNode([node, newNode]);
-    this.data.height = node.height + 1;
-    this.data.leaf = false;
-    calcBBox(this.data, this.toBBox);
-};
+        if (level) insertPath[level - 1].children.push(newNode);
+        else this._splitRoot(node, newNode);
+    },
+
+    _splitRoot: function (node, newNode) {
+        // split root node
+        this.data = createNode([node, newNode]);
+        this.data.height = node.height + 1;
+        this.data.leaf = false;
+        calcBBox(this.data, this.toBBox);
+    },
 
-RBush.prototype._chooseSplitIndex = function _chooseSplitIndex (node, m, M) {
-    var index;
-    var minOverlap = Infinity;
-    var minArea = Infinity;
+    _chooseSplitIndex: function (node, m, M) {
 
-    for (var i = m; i <= M - m; i++) {
-        var bbox1 = distBBox(node, 0, i, this.toBBox);
-        var bbox2 = distBBox(node, i, M, this.toBBox);
+        var i, bbox1, bbox2, overlap, area, minOverlap, minArea, index;
 
-        var overlap = intersectionArea(bbox1, bbox2);
-        var area = bboxArea(bbox1) + bboxArea(bbox2);
+        minOverlap = minArea = Infinity;
 
-        // choose distribution with minimum overlap
-        if (overlap < minOverlap) {
-            minOverlap = overlap;
-            index = i;
+        for (i = m; i <= M - m; i++) {
+            bbox1 = distBBox(node, 0, i, this.toBBox);
+            bbox2 = distBBox(node, i, M, this.toBBox);
 
-            minArea = area < minArea ? area : minArea;
+            overlap = intersectionArea(bbox1, bbox2);
+            area = bboxArea(bbox1) + bboxArea(bbox2);
 
-        } else if (overlap === minOverlap) {
-            // otherwise choose distribution with minimum area
-            if (area < minArea) {
-                minArea = area;
+            // choose distribution with minimum overlap
+            if (overlap < minOverlap) {
+                minOverlap = overlap;
                 index = i;
+
+                minArea = area < minArea ? area : minArea;
+
+            } else if (overlap === minOverlap) {
+                // otherwise choose distribution with minimum area
+                if (area < minArea) {
+                    minArea = area;
+                    index = i;
+                }
             }
         }
-    }
 
-    return index || M - m;
-};
+        return index;
+    },
 
-// sorts node children by the best axis for split
-RBush.prototype._chooseSplitAxis = function _chooseSplitAxis (node, m, M) {
-    var compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
-    var compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
-    var xMargin = this._allDistMargin(node, m, M, compareMinX);
-    var yMargin = this._allDistMargin(node, m, M, compareMinY);
+    // sorts node children by the best axis for split
+    _chooseSplitAxis: function (node, m, M) {
 
-    // if total distributions margin value is minimal for x, sort by minX,
-    // otherwise it's already sorted by minY
-    if (xMargin < yMargin) { node.children.sort(compareMinX); }
-};
+        var compareMinX = node.leaf ? this.compareMinX : compareNodeMinX,
+            compareMinY = node.leaf ? this.compareMinY : compareNodeMinY,
+            xMargin = this._allDistMargin(node, m, M, compareMinX),
+            yMargin = this._allDistMargin(node, m, M, compareMinY);
 
-// total margin of all possible split distributions where each node is at least m full
-RBush.prototype._allDistMargin = function _allDistMargin (node, m, M, compare) {
-    node.children.sort(compare);
+        // if total distributions margin value is minimal for x, sort by minX,
+        // otherwise it's already sorted by minY
+        if (xMargin < yMargin) node.children.sort(compareMinX);
+    },
 
-    var toBBox = this.toBBox;
-    var leftBBox = distBBox(node, 0, m, toBBox);
-    var rightBBox = distBBox(node, M - m, M, toBBox);
-    var margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
+    // total margin of all possible split distributions where each node is at least m full
+    _allDistMargin: function (node, m, M, compare) {
 
-    for (var i = m; i < M - m; i++) {
-        var child = node.children[i];
-        extend(leftBBox, node.leaf ? toBBox(child) : child);
-        margin += bboxMargin(leftBBox);
-    }
+        node.children.sort(compare);
 
-    for (var i$1 = M - m - 1; i$1 >= m; i$1--) {
-        var child$1 = node.children[i$1];
-        extend(rightBBox, node.leaf ? toBBox(child$1) : child$1);
-        margin += bboxMargin(rightBBox);
-    }
+        var toBBox = this.toBBox,
+            leftBBox = distBBox(node, 0, m, toBBox),
+            rightBBox = distBBox(node, M - m, M, toBBox),
+            margin = bboxMargin(leftBBox) + bboxMargin(rightBBox),
+            i, child;
 
-    return margin;
-};
+        for (i = m; i < M - m; i++) {
+            child = node.children[i];
+            extend(leftBBox, node.leaf ? toBBox(child) : child);
+            margin += bboxMargin(leftBBox);
+        }
 
-RBush.prototype._adjustParentBBoxes = function _adjustParentBBoxes (bbox, path, level) {
-    // adjust bboxes along the given tree path
-    for (var i = level; i >= 0; i--) {
-        extend(path[i], bbox);
-    }
-};
+        for (i = M - m - 1; i >= m; i--) {
+            child = node.children[i];
+            extend(rightBBox, node.leaf ? toBBox(child) : child);
+            margin += bboxMargin(rightBBox);
+        }
+
+        return margin;
+    },
+
+    _adjustParentBBoxes: function (bbox, path, level) {
+        // adjust bboxes along the given tree path
+        for (var i = level; i >= 0; i--) {
+            extend(path[i], bbox);
+        }
+    },
+
+    _condense: function (path) {
+        // go through the path, removing empty nodes and updating bboxes
+        for (var i = path.length - 1, siblings; i >= 0; i--) {
+            if (path[i].children.length === 0) {
+                if (i > 0) {
+                    siblings = path[i - 1].children;
+                    siblings.splice(siblings.indexOf(path[i]), 1);
+
+                } else this.clear();
 
-RBush.prototype._condense = function _condense (path) {
-    // go through the path, removing empty nodes and updating bboxes
-    for (var i = path.length - 1, siblings = (void 0); i >= 0; i--) {
-        if (path[i].children.length === 0) {
-            if (i > 0) {
-                siblings = path[i - 1].children;
-                siblings.splice(siblings.indexOf(path[i]), 1);
+            } else calcBBox(path[i], this.toBBox);
+        }
+    },
+
+    _initFormat: function (format) {
+        // data format (minX, minY, maxX, maxY accessors)
+
+        // uses eval-type function compilation instead of just accepting a toBBox function
+        // because the algorithms are very sensitive to sorting functions performance,
+        // so they should be dead simple and without inner calls
 
-            } else { this.clear(); }
+        var compareArr = ['return a', ' - b', ';'];
 
-        } else { calcBBox(path[i], this.toBBox); }
+        this.compareMinX = new Function('a', 'b', compareArr.join(format[0]));
+        this.compareMinY = new Function('a', 'b', compareArr.join(format[1]));
+
+        this.toBBox = new Function('a',
+            'return {minX: a' + format[0] +
+            ', minY: a' + format[1] +
+            ', maxX: a' + format[2] +
+            ', maxY: a' + format[3] + '};');
     }
 };
 
 function findItem(item, items, equalsFn) {
-    if (!equalsFn) { return items.indexOf(item); }
+    if (!equalsFn) return items.indexOf(item);
 
     for (var i = 0; i < items.length; i++) {
-        if (equalsFn(item, items[i])) { return i; }
+        if (equalsFn(item, items[i])) return i;
     }
     return -1;
 }
@@ -481,14 +473,14 @@ function calcBBox(node, toBBox) {
 
 // min bounding rectangle of node children from k to p-1
 function distBBox(node, k, p, toBBox, destNode) {
-    if (!destNode) { destNode = createNode(null); }
+    if (!destNode) destNode = createNode(null);
     destNode.minX = Infinity;
     destNode.minY = Infinity;
     destNode.maxX = -Infinity;
     destNode.maxY = -Infinity;
 
-    for (var i = k; i < p; i++) {
-        var child = node.children[i];
+    for (var i = k, child; i < p; i++) {
+        child = node.children[i];
         extend(destNode, node.leaf ? toBBox(child) : child);
     }
 
@@ -515,10 +507,10 @@ function enlargedArea(a, b) {
 }
 
 function intersectionArea(a, b) {
-    var minX = Math.max(a.minX, b.minX);
-    var minY = Math.max(a.minY, b.minY);
-    var maxX = Math.min(a.maxX, b.maxX);
-    var maxY = Math.min(a.maxY, b.maxY);
+    var minX = Math.max(a.minX, b.minX),
+        minY = Math.max(a.minY, b.minY),
+        maxX = Math.min(a.maxX, b.maxX),
+        maxY = Math.min(a.maxY, b.maxY);
 
     return Math.max(0, maxX - minX) *
            Math.max(0, maxY - minY);
@@ -554,21 +546,81 @@ function createNode(children) {
 // combines selection algorithm with binary divide & conquer approach
 
 function multiSelect(arr, left, right, n, compare) {
-    var stack = [left, right];
+    var stack = [left, right],
+        mid;
 
     while (stack.length) {
         right = stack.pop();
         left = stack.pop();
 
-        if (right - left <= n) { continue; }
+        if (right - left <= n) continue;
 
-        var mid = left + Math.ceil((right - left) / n / 2) * n;
+        mid = left + Math.ceil((right - left) / n / 2) * n;
         quickselect(arr, mid, left, right, compare);
 
         stack.push(left, mid, mid, right);
     }
 }
 
-return RBush;
+},{"quickselect":2}],2:[function(require,module,exports){
+'use strict';
+
+module.exports = quickselect;
+module.exports.default = quickselect;
+
+function quickselect(arr, k, left, right, compare) {
+    quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare);
+};
+
+function quickselectStep(arr, k, left, right, compare) {
+
+    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));
+            quickselectStep(arr, k, newLeft, newRight, compare);
+        }
+
+        var t = arr[k];
+        var i = left;
+        var j = right;
+
+        swap(arr, left, k);
+        if (compare(arr[right], t) > 0) swap(arr, left, right);
+
+        while (i < j) {
+            swap(arr, i, j);
+            i++;
+            j--;
+            while (compare(arr[i], t) < 0) i++;
+            while (compare(arr[j], t) > 0) j--;
+        }
+
+        if (compare(arr[left], t) === 0) swap(arr, left, j);
+        else {
+            j++;
+            swap(arr, j, right);
+        }
+
+        if (j <= k) left = j + 1;
+        if (k <= j) right = j - 1;
+    }
+}
+
+function swap(arr, i, j) {
+    var tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+}
+
+function defaultCompare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
 
-}));
+},{}]},{},[1])(1)
+});