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

package/node_modules/rbush/index.js

@@ -1,30 +1,46 @@
-import quickselect from 'quickselect';
-
-export default class RBush {
-    constructor(maxEntries = 9) {
-        // 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();
+'use strict';
+
+module.exports = rbush;
+module.exports.default = rbush;
+
+var quickselect = require('quickselect');
+
+function rbush(maxEntries, format) {
+    if (!(this instanceof rbush)) return new rbush(maxEntries, format);
+
+    // 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 (format) {
+        this._initFormat(format);
     }
 
-    all() {
+    this.clear();
+}
+
+rbush.prototype = {
+
+    all: function () {
         return this._all(this.data, []);
-    }
+    },
 
-    search(bbox) {
-        let node = this.data;
-        const result = [];
+    search: function (bbox) {
+
+        var node = this.data,
+            result = [],
+            toBBox = this.toBBox;
 
         if (!intersects(bbox, node)) return result;
 
-        const toBBox = this.toBBox;
-        const nodesToSearch = [];
+        var nodesToSearch = [],
+            i, len, child, childBBox;
 
         while (node) {
-            for (let i = 0; i < node.children.length; i++) {
-                const child = node.children[i];
-                const childBBox = node.leaf ? toBBox(child) : child;
+            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) result.push(child);
@@ -36,18 +52,23 @@ export default class RBush {
         }
 
         return result;
-    }
+    },
 
-    collides(bbox) {
-        let node = this.data;
+    collides: function (bbox) {
+
+        var node = this.data,
+            toBBox = this.toBBox;
 
         if (!intersects(bbox, node)) return false;
 
-        const nodesToSearch = [];
+        var nodesToSearch = [],
+            i, len, child, childBBox;
+
         while (node) {
-            for (let i = 0; i < node.children.length; i++) {
-                const child = node.children[i];
-                const childBBox = node.leaf ? this.toBBox(child) : child;
+            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;
@@ -58,20 +79,20 @@ export default class RBush {
         }
 
         return false;
-    }
+    },
 
-    load(data) {
+    load: function (data) {
         if (!(data && data.length)) return this;
 
         if (data.length < this._minEntries) {
-            for (let i = 0; i < data.length; i++) {
+            for (var i = 0, len = data.length; i < len; i++) {
                 this.insert(data[i]);
             }
             return this;
         }
 
         // recursively build the tree with the given data from scratch using OMT algorithm
-        let node = this._build(data.slice(), 0, data.length - 1, 0);
+        var node = this._build(data.slice(), 0, data.length - 1, 0);
 
         if (!this.data.children.length) {
             // save as is if tree is empty
@@ -84,7 +105,7 @@ export default class RBush {
         } else {
             if (this.data.height < node.height) {
                 // swap trees if inserted one is bigger
-                const tmpNode = this.data;
+                var tmpNode = this.data;
                 this.data = node;
                 node = tmpNode;
             }
@@ -94,26 +115,26 @@ export default class RBush {
         }
 
         return this;
-    }
+    },
 
-    insert(item) {
+    insert: function (item) {
         if (item) this._insert(item, this.data.height - 1);
         return this;
-    }
+    },
 
-    clear() {
+    clear: function () {
         this.data = createNode([]);
         return this;
-    }
+    },
 
-    remove(item, equalsFn) {
+    remove: function (item, equalsFn) {
         if (!item) return this;
 
-        let node = this.data;
-        const bbox = this.toBBox(item);
-        const path = [];
-        const indexes = [];
-        let 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) {
@@ -126,7 +147,7 @@ export default class RBush {
             }
 
             if (node.leaf) { // check current node
-                const index = findItem(item, node.children, equalsFn);
+                index = findItem(item, node.children, equalsFn);
 
                 if (index !== -1) {
                     // item found, remove the item and condense tree upwards
@@ -153,36 +174,36 @@ export default class RBush {
         }
 
         return this;
-    }
+    },
 
-    toBBox(item) { return item; }
+    toBBox: function (item) { return item; },
 
-    compareMinX(a, b) { return a.minX - b.minX; }
-    compareMinY(a, b) { return a.minY - b.minY; }
+    compareMinX: compareNodeMinX,
+    compareMinY: compareNodeMinY,
 
-    toJSON() { return this.data; }
+    toJSON: function () { return this.data; },
 
-    fromJSON(data) {
+    fromJSON: function (data) {
         this.data = data;
         return this;
-    }
+    },
 
-    _all(node, result) {
-        const nodesToSearch = [];
+    _all: function (node, result) {
+        var nodesToSearch = [];
         while (node) {
-            if (node.leaf) result.push(...node.children);
-            else nodesToSearch.push(...node.children);
+            if (node.leaf) result.push.apply(result, node.children);
+            else nodesToSearch.push.apply(nodesToSearch, node.children);
 
             node = nodesToSearch.pop();
         }
         return result;
-    }
+    },
 
-    _build(items, left, right, height) {
+    _build: function (items, left, right, height) {
 
-        const N = right - left + 1;
-        let M = this._maxEntries;
-        let node;
+        var N = right - left + 1,
+            M = this._maxEntries,
+            node;
 
         if (N <= M) {
             // reached leaf level; return leaf
@@ -205,20 +226,21 @@ export default class RBush {
 
         // split the items into M mostly square tiles
 
-        const N2 = Math.ceil(N / M);
-        const 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);
 
-        for (let i = left; i <= right; i += N1) {
+        for (i = left; i <= right; i += N1) {
 
-            const right2 = Math.min(i + N1 - 1, right);
+            right2 = Math.min(i + N1 - 1, right);
 
             multiSelect(items, i, right2, N2, this.compareMinY);
 
-            for (let j = i; j <= right2; j += N2) {
+            for (j = i; j <= right2; j += N2) {
 
-                const 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));
@@ -228,22 +250,23 @@ export default class RBush {
         calcBBox(node, this.toBBox);
 
         return node;
-    }
+    },
+
+    _chooseSubtree: function (bbox, node, level, path) {
+
+        var i, len, child, targetNode, area, enlargement, minArea, minEnlargement;
 
-    _chooseSubtree(bbox, node, level, path) {
         while (true) {
             path.push(node);
 
             if (node.leaf || path.length - 1 === level) break;
 
-            let minArea = Infinity;
-            let minEnlargement = Infinity;
-            let targetNode;
+            minArea = minEnlargement = Infinity;
 
-            for (let i = 0; i < node.children.length; i++) {
-                const child = node.children[i];
-                const area = bboxArea(child);
-                const enlargement = enlargedArea(bbox, child) - 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) {
@@ -264,14 +287,16 @@ export default class RBush {
         }
 
         return node;
-    }
+    },
 
-    _insert(item, level, isNode) {
-        const bbox = isNode ? item : this.toBBox(item);
-        const insertPath = [];
+    _insert: function (item, level, isNode) {
+
+        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
-        const node = this._chooseSubtree(bbox, this.data, level, insertPath);
+        var node = this._chooseSubtree(bbox, this.data, level, insertPath);
 
         // put the item into the node
         node.children.push(item);
@@ -287,19 +312,20 @@ export default class RBush {
 
         // adjust bboxes along the insertion path
         this._adjustParentBBoxes(bbox, insertPath, level);
-    }
+    },
 
     // split overflowed node into two
-    _split(insertPath, level) {
-        const node = insertPath[level];
-        const M = node.children.length;
-        const m = this._minEntries;
+    _split: function (insertPath, level) {
+
+        var node = insertPath[level],
+            M = node.children.length,
+            m = this._minEntries;
 
         this._chooseSplitAxis(node, m, M);
 
-        const splitIndex = this._chooseSplitIndex(node, m, M);
+        var splitIndex = this._chooseSplitIndex(node, m, M);
 
-        const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
+        var newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
         newNode.height = node.height;
         newNode.leaf = node.leaf;
 
@@ -308,27 +334,28 @@ export default class RBush {
 
         if (level) insertPath[level - 1].children.push(newNode);
         else this._splitRoot(node, newNode);
-    }
+    },
 
-    _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);
-    }
+    },
+
+    _chooseSplitIndex: function (node, m, M) {
 
-    _chooseSplitIndex(node, m, M) {
-        let index;
-        let minOverlap = Infinity;
-        let minArea = Infinity;
+        var i, bbox1, bbox2, overlap, area, minOverlap, minArea, index;
 
-        for (let i = m; i <= M - m; i++) {
-            const bbox1 = distBBox(node, 0, i, this.toBBox);
-            const bbox2 = distBBox(node, i, M, this.toBBox);
+        minOverlap = minArea = Infinity;
 
-            const overlap = intersectionArea(bbox1, bbox2);
-            const area = bboxArea(bbox1) + bboxArea(bbox2);
+        for (i = m; i <= M - m; i++) {
+            bbox1 = distBBox(node, 0, i, this.toBBox);
+            bbox2 = distBBox(node, i, M, this.toBBox);
+
+            overlap = intersectionArea(bbox1, bbox2);
+            area = bboxArea(bbox1) + bboxArea(bbox2);
 
             // choose distribution with minimum overlap
             if (overlap < minOverlap) {
@@ -346,55 +373,58 @@ export default class RBush {
             }
         }
 
-        return index || M - m;
-    }
+        return index;
+    },
 
     // sorts node children by the best axis for split
-    _chooseSplitAxis(node, m, M) {
-        const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
-        const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
-        const xMargin = this._allDistMargin(node, m, M, compareMinX);
-        const yMargin = this._allDistMargin(node, m, M, compareMinY);
+    _chooseSplitAxis: function (node, m, M) {
+
+        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);
 
         // 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);
-    }
+    },
 
     // total margin of all possible split distributions where each node is at least m full
-    _allDistMargin(node, m, M, compare) {
+    _allDistMargin: function (node, m, M, compare) {
+
         node.children.sort(compare);
 
-        const toBBox = this.toBBox;
-        const leftBBox = distBBox(node, 0, m, toBBox);
-        const rightBBox = distBBox(node, M - m, M, toBBox);
-        let margin = bboxMargin(leftBBox) + 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;
 
-        for (let i = m; i < M - m; i++) {
-            const child = node.children[i];
+        for (i = m; i < M - m; i++) {
+            child = node.children[i];
             extend(leftBBox, node.leaf ? toBBox(child) : child);
             margin += bboxMargin(leftBBox);
         }
 
-        for (let i = M - m - 1; i >= m; i--) {
-            const child = node.children[i];
+        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(bbox, path, level) {
+    _adjustParentBBoxes: function (bbox, path, level) {
         // adjust bboxes along the given tree path
-        for (let i = level; i >= 0; i--) {
+        for (var i = level; i >= 0; i--) {
             extend(path[i], bbox);
         }
-    }
+    },
 
-    _condense(path) {
+    _condense: function (path) {
         // go through the path, removing empty nodes and updating bboxes
-        for (let i = path.length - 1, siblings; i >= 0; i--) {
+        for (var i = path.length - 1, siblings; i >= 0; i--) {
             if (path[i].children.length === 0) {
                 if (i > 0) {
                     siblings = path[i - 1].children;
@@ -404,13 +434,32 @@ export default class RBush {
 
             } 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
+
+        var compareArr = ['return a', ' - b', ';'];
+
+        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);
 
-    for (let i = 0; i < items.length; i++) {
+    for (var i = 0; i < items.length; i++) {
         if (equalsFn(item, items[i])) return i;
     }
     return -1;
@@ -429,8 +478,8 @@ function distBBox(node, k, p, toBBox, destNode) {
     destNode.maxX = -Infinity;
     destNode.maxY = -Infinity;
 
-    for (let i = k; i < p; i++) {
-        const child = node.children[i];
+    for (var i = k, child; i < p; i++) {
+        child = node.children[i];
         extend(destNode, node.leaf ? toBBox(child) : child);
     }
 
@@ -457,10 +506,10 @@ function enlargedArea(a, b) {
 }
 
 function intersectionArea(a, b) {
-    const minX = Math.max(a.minX, b.minX);
-    const minY = Math.max(a.minY, b.minY);
-    const maxX = Math.min(a.maxX, b.maxX);
-    const 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);
@@ -482,7 +531,7 @@ function intersects(a, b) {
 
 function createNode(children) {
     return {
-        children,
+        children: children,
         height: 1,
         leaf: true,
         minX: Infinity,
@@ -496,7 +545,8 @@ function createNode(children) {
 // combines selection algorithm with binary divide & conquer approach
 
 function multiSelect(arr, left, right, n, compare) {
-    const stack = [left, right];
+    var stack = [left, right],
+        mid;
 
     while (stack.length) {
         right = stack.pop();
@@ -504,7 +554,7 @@ function multiSelect(arr, left, right, n, compare) {
 
         if (right - left <= n) continue;
 
-        const 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);

package/node_modules/rbush/package.json

@@ -1,63 +1,12 @@
 {
-  "_from": "rbush@^3.0.1",
-  "_id": "rbush@3.0.1",
-  "_inBundle": false,
-  "_integrity": "sha512-XRaVO0YecOpEuIvbhbpTrZgoiI6xBlz6hnlr6EHhd+0x9ase6EmeN+hdwwUaJvLcsFFQ8iWVF1GAK1yB0BWi0w==",
-  "_location": "/rbush",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "rbush@^3.0.1",
-    "name": "rbush",
-    "escapedName": "rbush",
-    "rawSpec": "^3.0.1",
-    "saveSpec": null,
-    "fetchSpec": "^3.0.1"
-  },
-  "_requiredBy": [
-    "/concaveman",
-    "/geojson-rbush"
-  ],
-  "_resolved": "https://registry.npmjs.org/rbush/-/rbush-3.0.1.tgz",
-  "_shasum": "5fafa8a79b3b9afdfe5008403a720cc1de882ecf",
-  "_spec": "rbush@^3.0.1",
-  "_where": "/Users/conway/Projects/TAKreg/node_modules/geojson-rbush",
-  "author": {
-    "name": "Vladimir Agafonkin"
-  },
-  "browser": "rbush.min.js",
-  "bugs": {
-    "url": "https://github.com/mourner/rbush/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "quickselect": "^2.0.0"
-  },
-  "deprecated": false,
+  "name": "rbush",
+  "version": "2.0.2",
   "description": "High-performance 2D spatial index for rectangles (based on R*-tree with bulk loading and bulk insertion algorithms)",
-  "devDependencies": {
-    "benchmark": "^2.1.4",
-    "c8": "^5.0.1",
-    "eslint": "^6.1.0",
-    "eslint-config-mourner": "^3.0.0",
-    "esm": "^3.2.25",
-    "rollup": "^1.17.0",
-    "rollup-plugin-buble": "^0.19.8",
-    "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-terser": "^5.1.1",
-    "tape": "^4.11.0"
-  },
-  "eslintConfig": {
-    "extends": "mourner"
-  },
-  "files": [
-    "index.js",
-    "rbush.js",
-    "rbush.min.js"
-  ],
   "homepage": "https://github.com/mourner/rbush",
-  "jsdelivr": "rbush.min.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/mourner/rbush.git"
+  },
   "keywords": [
     "spatial",
     "tree",
@@ -66,22 +15,41 @@
     "index",
     "math"
   ],
+  "author": "Vladimir Agafonkin",
   "license": "MIT",
-  "main": "rbush.js",
-  "module": "index.js",
-  "name": "rbush",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/mourner/rbush.git"
+  "main": "index.js",
+  "jsdelivr": "rbush.js",
+  "unpkg": "rbush.js",
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "browserify": "^14.5.0",
+    "eslint": "^4.13.1",
+    "eslint-config-mourner": "^2.0.3",
+    "faucet": "0.0.1",
+    "istanbul": "~0.4.5",
+    "tape": "^4.8.0",
+    "uglify-js": "^3.2.2"
   },
   "scripts": {
-    "build": "rollup -c",
-    "cov": "c8 npm run test",
-    "perf": "node -r esm ./bench/perf.js",
-    "prepublishOnly": "npm run build",
-    "pretest": "eslint index.js test/test.js bench/*.js",
-    "test": "tape -r esm test/test.js"
+    "test": "eslint index.js test/test.js && node test/test.js | faucet",
+    "perf": "node ./bench/perf.js",
+    "cov": "istanbul cover test/test.js -x test/test.js",
+    "build": "browserify index.js -s rbush -o rbush.js",
+    "build-min": "browserify index.js -s rbush | uglifyjs -c warnings=false -m > rbush.min.js",
+    "prepare": "npm run build && npm run build-min"
+  },
+  "files": [
+    "rbush.js",
+    "rbush.min.js"
+  ],
+  "eslintConfig": {
+    "extends": "mourner",
+    "rules": {
+      "new-cap": 0,
+      "consistent-return": 0
+    }
   },
-  "unpkg": "rbush.min.js",
-  "version": "3.0.1"
+  "dependencies": {
+    "quickselect": "^1.0.1"
+  }
 }