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

package/node_modules/{@turf/unkink-polygon → concaveman}/node_modules/rbush/index.js

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

package/node_modules/concaveman/node_modules/rbush/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "rbush",
+  "version": "3.0.1",
+  "description": "High-performance 2D spatial index for rectangles (based on R*-tree with bulk loading and bulk insertion algorithms)",
+  "homepage": "https://github.com/mourner/rbush",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/mourner/rbush.git"
+  },
+  "keywords": [
+    "spatial",
+    "tree",
+    "search",
+    "rectangle",
+    "index",
+    "math"
+  ],
+  "author": "Vladimir Agafonkin",
+  "license": "MIT",
+  "main": "rbush.js",
+  "module": "index.js",
+  "browser": "rbush.min.js",
+  "jsdelivr": "rbush.min.js",
+  "unpkg": "rbush.min.js",
+  "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"
+  },
+  "scripts": {
+    "pretest": "eslint index.js test/test.js bench/*.js",
+    "test": "tape -r esm test/test.js",
+    "perf": "node -r esm ./bench/perf.js",
+    "cov": "c8 npm run test",
+    "build": "rollup -c",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "index.js",
+    "rbush.js",
+    "rbush.min.js"
+  ],
+  "eslintConfig": {
+    "extends": "mourner"
+  },
+  "dependencies": {
+    "quickselect": "^2.0.0"
+  }
+}