node-red-contrib-tak-registration 0.2.2 → 0.3.0

package/node_modules/splaytree/typings/index.d.ts

@@ -0,0 +1,82 @@
+import Node from './node';
+import { Key } from './types';
+export declare type Comparator<Key> = (a: Key, b: Key) => number;
+export declare type Visitor<Key, Value> = (node: Node<Key, Value>) => void;
+export declare type NodePrinter<Key, Value> = (node: Node<Key, Value>) => string;
+declare function DEFAULT_COMPARE(a: Key, b: Key): number;
+export default class Tree<Key = number, Value = any> {
+    private _comparator;
+    private _root;
+    private _size;
+    constructor(comparator?: typeof DEFAULT_COMPARE);
+    /**
+     * Inserts a key, allows duplicates
+     */
+    insert(key: Key, data?: Value): Node<Key, Value>;
+    /**
+     * Adds a key, if it is not present in the tree
+     */
+    add(key: Key, data?: Value): Node<Key, Value>;
+    /**
+     * @param  {Key} key
+     * @return {Node|null}
+     */
+    remove(key: Key): void;
+    /**
+     * Deletes i from the tree if it's there
+     */
+    private _remove;
+    /**
+     * Removes and returns the node with smallest key
+     */
+    pop(): {
+        key: Key;
+        data: Value;
+    } | null;
+    /**
+     * Find without splaying
+     */
+    findStatic(key: Key): Node<Key, Value> | null;
+    find(key: Key): Node<Key, Value> | null;
+    contains(key: Key): boolean;
+    forEach(visitor: Visitor<Key, Value>, ctx?: any): Tree<Key, Value>;
+    /**
+     * Walk key range from `low` to `high`. Stops if `fn` returns a value.
+     */
+    range(low: Key, high: Key, fn: Visitor<Key, Value>, ctx?: any): Tree<Key, Value>;
+    /**
+     * Returns array of keys
+     */
+    keys(): Key[];
+    /**
+     * Returns array of all the data in the nodes
+     */
+    values(): Value[];
+    min(): Key | null;
+    max(): Key | null;
+    minNode(t?: Node<Key, Value>): Node<Key, Value> | null;
+    maxNode(t?: Node<Key, Value>): Node<Key, Value> | null;
+    /**
+     * Returns node at given index
+     */
+    at(index: number): Node<Key, Value> | null;
+    next(d: Node<Key, Value>): Node<Key, Value> | null;
+    prev(d: Node<Key, Value>): Node<Key, Value> | null;
+    clear(): Tree<Key, Value>;
+    toList(): Node<any, any>;
+    /**
+     * Bulk-load items. Both array have to be same size
+     */
+    load(keys: Key[], values?: Value[], presort?: boolean): this;
+    isEmpty(): boolean;
+    readonly size: number;
+    readonly root: Node<Key, Value> | null;
+    toString(printNode?: NodePrinter<Key, Value>): string;
+    update(key: Key, newKey: Key, newData?: Value): void;
+    split(key: Key): {
+        left: Node<any, any>;
+        right: Node<any, any>;
+    };
+    [Symbol.iterator](): IterableIterator<Node<Key, Value>>;
+}
+export {};

package/node_modules/splaytree/typings/node.d.ts

@@ -0,0 +1,8 @@
+export default class Node<Key, Value> {
+    key: Key;
+    data: any;
+    left: Node<Key, Value> | null;
+    right: Node<Key, Value> | null;
+    next: Node<Key, Value> | null;
+    constructor(key: Key, data?: any);
+}

package/node_modules/splaytree/typings/types.d.ts

@@ -0,0 +1,2 @@
+export declare type Key = number | any;
+export declare type Value = any;

package/node_modules/tinyqueue/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2017, Vladimir Agafonkin
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/node_modules/tinyqueue/README.md

@@ -0,0 +1,59 @@
+## tinyqueue
+
+The smallest and simplest binary heap priority queue in JavaScript.
+
+```js
+// create an empty priority queue
+var queue = new TinyQueue();
+
+// add some items
+queue.push(7);
+queue.push(5);
+queue.push(10);
+
+// remove the top item
+var top = queue.pop(); // returns 5
+
+// return the top item (without removal)
+top = queue.peek(); // returns 7
+
+// get queue length
+queue.length; // returns 2
+
+// create a priority queue from an existing array (modifies the array)
+queue = new TinyQueue([7, 5, 10]);
+
+// pass a custom item comparator as a second argument
+queue = new TinyQueue([{value: 5}, {value: 7}], function (a, b) {
+	return a.value - b.value;
+});
+
+// turn a queue into a sorted array
+var array = [];
+while (queue.length) array.push(queue.pop());
+```
+
+For a faster number-based queue, see [flatqueue](https://github.com/mourner/flatqueue).
+
+### Install
+
+Install using NPM (`npm install tinyqueue`) or Yarn (`yarn add tinyqueue`), then:
+
+```js
+// import as an ES module
+import TinyQueue from 'tinyqueue';
+
+// or require in Node / Browserify
+const TinyQueue = require('tinyqueue');
+```
+
+Or use a browser build directly:
+
+```html
+<script src="https://unpkg.com/tinyqueue@2.0.0/tinyqueue.min.js"></script>
+```
+
+### Thanks
+
+Inspired by [js-priority-queue](https://github.com/adamhooper/js-priority-queue)
+by [Adam Hooper](https://github.com/adamhooper).

package/node_modules/tinyqueue/index.d.ts

@@ -0,0 +1,11 @@
+export declare type Item = any;
+export declare type Comparator<Item> = (a: Item, b: Item) => number;
+
+export default class TinyQueue<Item> {
+  public data : Item[];
+  public length : number;
+  constructor (items? : Item[], compare? : Comparator<Item>);
+  peek () : Item | undefined;
+  pop () : Item | undefined;
+  push (item: Item) : void;
+}

package/node_modules/tinyqueue/index.js

@@ -0,0 +1,79 @@
+
+export default class TinyQueue {
+    constructor(data = [], compare = defaultCompare) {
+        this.data = data;
+        this.length = this.data.length;
+        this.compare = compare;
+
+        if (this.length > 0) {
+            for (let i = (this.length >> 1) - 1; i >= 0; i--) this._down(i);
+        }
+    }
+
+    push(item) {
+        this.data.push(item);
+        this.length++;
+        this._up(this.length - 1);
+    }
+
+    pop() {
+        if (this.length === 0) return undefined;
+
+        const top = this.data[0];
+        const bottom = this.data.pop();
+        this.length--;
+
+        if (this.length > 0) {
+            this.data[0] = bottom;
+            this._down(0);
+        }
+
+        return top;
+    }
+
+    peek() {
+        return this.data[0];
+    }
+
+    _up(pos) {
+        const {data, compare} = this;
+        const item = data[pos];
+
+        while (pos > 0) {
+            const parent = (pos - 1) >> 1;
+            const current = data[parent];
+            if (compare(item, current) >= 0) break;
+            data[pos] = current;
+            pos = parent;
+        }
+
+        data[pos] = item;
+    }
+
+    _down(pos) {
+        const {data, compare} = this;
+        const halfLength = this.length >> 1;
+        const item = data[pos];
+
+        while (pos < halfLength) {
+            let left = (pos << 1) + 1;
+            let best = data[left];
+            const right = left + 1;
+
+            if (right < this.length && compare(data[right], best) < 0) {
+                left = right;
+                best = data[right];
+            }
+            if (compare(best, item) >= 0) break;
+
+            data[pos] = best;
+            pos = left;
+        }
+
+        data[pos] = item;
+    }
+}
+
+function defaultCompare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}

package/node_modules/tinyqueue/package.json

@@ -0,0 +1,78 @@
+{
+  "_from": "tinyqueue@^2.0.3",
+  "_id": "tinyqueue@2.0.3",
+  "_inBundle": false,
+  "_integrity": "sha512-ppJZNDuKGgxzkHihX8v9v9G5f+18gzaTfrukGrq6ueg0lmH4nqVnA2IPG0AEH3jKEk2GRJCUhDoqpoiw3PHLBA==",
+  "_location": "/tinyqueue",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "tinyqueue@^2.0.3",
+    "name": "tinyqueue",
+    "escapedName": "tinyqueue",
+    "rawSpec": "^2.0.3",
+    "saveSpec": null,
+    "fetchSpec": "^2.0.3"
+  },
+  "_requiredBy": [
+    "/concaveman"
+  ],
+  "_resolved": "https://registry.npmjs.org/tinyqueue/-/tinyqueue-2.0.3.tgz",
+  "_shasum": "64d8492ebf39e7801d7bd34062e29b45b2035f08",
+  "_spec": "tinyqueue@^2.0.3",
+  "_where": "/Users/conway/Projects/TAKreg/node_modules/concaveman",
+  "author": "",
+  "bugs": {
+    "url": "https://github.com/mourner/tinyqueue/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "The smallest and simplest JavaScript priority queue",
+  "devDependencies": {
+    "eslint": "^5.16.0",
+    "eslint-config-mourner": "^3.0.0",
+    "esm": "^3.2.25",
+    "rollup": "^1.15.4",
+    "rollup-plugin-buble": "^0.19.6",
+    "rollup-plugin-terser": "^5.0.0",
+    "tape": "^4.10.2"
+  },
+  "eslintConfig": {
+    "extends": "mourner"
+  },
+  "files": [
+    "index.js",
+    "tinyqueue.js",
+    "tinyqueue.min.js",
+    "index.d.ts"
+  ],
+  "homepage": "https://github.com/mourner/tinyqueue",
+  "jsdelivr": "tinyqueue.min.js",
+  "keywords": [
+    "queue",
+    "priority",
+    "binary heap",
+    "data structures"
+  ],
+  "license": "ISC",
+  "main": "tinyqueue.js",
+  "module": "index.js",
+  "name": "tinyqueue",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mourner/tinyqueue.git"
+  },
+  "scripts": {
+    "bench": "node -r esm bench.js",
+    "build": "rollup -c",
+    "lint": "eslint index.js test.js bench.js rollup.config.js",
+    "prepublishOnly": "npm test",
+    "pretest": "npm run lint",
+    "test": "tape -r esm test.js",
+    "watch": "rollup -cw"
+  },
+  "types": "index.d.ts",
+  "unpkg": "tinyqueue.min.js",
+  "version": "2.0.3"
+}

package/node_modules/tinyqueue/tinyqueue.js

@@ -0,0 +1,93 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+typeof define === 'function' && define.amd ? define(factory) :
+(global = global || self, global.TinyQueue = factory());
+}(this, function () { 'use strict';
+
+var TinyQueue = function TinyQueue(data, compare) {
+    if ( data === void 0 ) data = [];
+    if ( compare === void 0 ) compare = defaultCompare;
+
+    this.data = data;
+    this.length = this.data.length;
+    this.compare = compare;
+
+    if (this.length > 0) {
+        for (var i = (this.length >> 1) - 1; i >= 0; i--) { this._down(i); }
+    }
+};
+
+TinyQueue.prototype.push = function push (item) {
+    this.data.push(item);
+    this.length++;
+    this._up(this.length - 1);
+};
+
+TinyQueue.prototype.pop = function pop () {
+    if (this.length === 0) { return undefined; }
+
+    var top = this.data[0];
+    var bottom = this.data.pop();
+    this.length--;
+
+    if (this.length > 0) {
+        this.data[0] = bottom;
+        this._down(0);
+    }
+
+    return top;
+};
+
+TinyQueue.prototype.peek = function peek () {
+    return this.data[0];
+};
+
+TinyQueue.prototype._up = function _up (pos) {
+    var ref = this;
+        var data = ref.data;
+        var compare = ref.compare;
+    var item = data[pos];
+
+    while (pos > 0) {
+        var parent = (pos - 1) >> 1;
+        var current = data[parent];
+        if (compare(item, current) >= 0) { break; }
+        data[pos] = current;
+        pos = parent;
+    }
+
+    data[pos] = item;
+};
+
+TinyQueue.prototype._down = function _down (pos) {
+    var ref = this;
+        var data = ref.data;
+        var compare = ref.compare;
+    var halfLength = this.length >> 1;
+    var item = data[pos];
+
+    while (pos < halfLength) {
+        var left = (pos << 1) + 1;
+        var best = data[left];
+        var right = left + 1;
+
+        if (right < this.length && compare(data[right], best) < 0) {
+            left = right;
+            best = data[right];
+        }
+        if (compare(best, item) >= 0) { break; }
+
+        data[pos] = best;
+        pos = left;
+    }
+
+    data[pos] = item;
+};
+
+function defaultCompare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+
+return TinyQueue;
+
+}));

package/node_modules/tinyqueue/tinyqueue.min.js

@@ -0,0 +1 @@
+!function(t,i){"object"==typeof exports&&"undefined"!=typeof module?module.exports=i():"function"==typeof define&&define.amd?define(i):(t=t||self).TinyQueue=i()}(this,function(){"use strict";var t=function(t,e){if(void 0===t&&(t=[]),void 0===e&&(e=i),this.data=t,this.length=this.data.length,this.compare=e,this.length>0)for(var n=(this.length>>1)-1;n>=0;n--)this._down(n)};function i(t,i){return t<i?-1:t>i?1:0}return t.prototype.push=function(t){this.data.push(t),this.length++,this._up(this.length-1)},t.prototype.pop=function(){if(0!==this.length){var t=this.data[0],i=this.data.pop();return this.length--,this.length>0&&(this.data[0]=i,this._down(0)),t}},t.prototype.peek=function(){return this.data[0]},t.prototype._up=function(t){for(var i=this.data,e=this.compare,n=i[t];t>0;){var o=t-1>>1,h=i[o];if(e(n,h)>=0)break;i[t]=h,t=o}i[t]=n},t.prototype._down=function(t){for(var i=this.data,e=this.compare,n=this.length>>1,o=i[t];t<n;){var h=1+(t<<1),s=i[h],a=h+1;if(a<this.length&&e(i[a],s)<0&&(h=a,s=i[a]),e(s,o)>=0)break;i[t]=s,t=h}i[t]=o},t});

package/node_modules/topojson-client/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2012-2019 Michael Bostock
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.