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

package/node_modules/splaytree/Readme.md

@@ -1,25 +1,24 @@
-# Fast splay tree [![npm version](https://badge.fury.io/js/splaytree.svg)](https://badge.fury.io/js/splaytree) [![build](https://travis-ci.org/w8r/splay-tree.svg?branch=master)](https://travis-ci.org/w8r/splay-tree) ![deps](https://david-dm.org/w8r/splay-tree/status.svg) [![codecov](https://codecov.io/gh/w8r/splay-tree/branch/master/graph/badge.svg)](https://codecov.io/gh/w8r/splay-tree)
+# Fast splay tree [![npm version](https://badge.fury.io/js/splaytree.svg)](https://badge.fury.io/js/splaytree) [![codecov](https://codecov.io/gh/w8r/splay-tree/branch/master/graph/badge.svg)](https://codecov.io/gh/w8r/splay-tree)
 
 [Splay-tree](https://en.wikipedia.org/wiki/Splay_tree): **[fast](#benchmarks)**(non-recursive) and **simple**(< 1000 lines of code)
 Implementation is adapted directly from Wikipedia with the same API as [w8r/avl](https://github.com/w8r/avl), to run the benchmarks against other trees.
 
-
 This tree is based on **top-down** splaying algorithm by D.Sleator. It supports
- - splitting, merging
- - updating of the keys
- - bulk loading of the items into an empty or non-empty tree
- - insertion with duplicates or no duplicates
- - lookup without splaying
 
-![Splay-tree](https://i.stack.imgur.com/CNSAZ.png)
+- splitting, merging
+- updating of the keys
+- bulk loading of the items into an empty or non-empty tree
+- insertion with duplicates or no duplicates
+- lookup without splaying
 
-| Operation     | Average       | Worst case             |
-| ------------- | ------------- | ---------------------- |
-| Space         | **O(n)**      | **O(n)**               |
-| Search        | **O(log n)**  | **amortized O(log n)** |
-| Insert        | **O(log n)**  | **amortized O(log n)** |
-| Delete        | **O(log n)**  | **amortized O(log n)** |
+![Splay-tree](https://i.stack.imgur.com/CNSAZ.png)
 
+| Operation | Average      | Worst case             |
+| --------- | ------------ | ---------------------- |
+| Space     | **O(n)**     | **O(n)**               |
+| Search    | **O(log n)** | **amortized O(log n)** |
+| Insert    | **O(log n)** | **amortized O(log n)** |
+| Delete    | **O(log n)** | **amortized O(log n)** |
 
 ## Install
 
@@ -28,11 +27,12 @@ npm i -S splaytree
 ```
 
 ```js
-import SplayTree from 'splaytree';
+import SplayTree from "splaytree";
 const tree = new SplayTree();
 ```
 
 Or get it from CDN
+
 ```html
 <script src="https://unpkg.com/splaytree"></script>
 <script>
@@ -40,56 +40,58 @@ Or get it from CDN
   ...
 </script>
 ```
+
 Or use the compiled version 'dist/splay.js'.
 
 [Try it in your browser](https://npm.runkit.com/splaytree)
 
 ## API
 
-* `new SplayTree([comparator])`, where `comparator` is optional comparison function
-* `tree.insert(key:any, [data:any]):Node` - Insert item, allow duplicate keys
-* `tree.add(key:any, [data:any]):Node` - Insert item if it is not present
-* `tree.remove(key:any)` - Remove item
-* `tree.find(key):Node|Null` - Return node by its key
-* `tree.findStatic(key):Node|Null` - Return node by its key (doesn't re-balance the tree)
-* `tree.at(index:Number):Node|Null` - Return node by its index in sorted order of keys
-* `tree.contains(key):Boolean` - Whether a node with the given key is in the tree
-* `tree.forEach(function(node) {...}):Tree` In-order traversal
-* `tree.keys():Array<key>` - Returns the array of keys in order
-* `tree.values():Array<*>` - Returns the array of data fields in order
-* `tree.range(lo, high, function(node) {} [, context]):Tree` - Walks the range of keys in order. Stops, if the visitor function returns a non-zero value.
-* `tree.pop():Node` - Removes smallest node
-* `tree.min():key` - Returns min key
-* `tree.max():key` - Returns max key
-* `tree.minNode():Node` - Returns the node with smallest key
-* `tree.maxNode():Node` - Returns the node with highest key
-* `tree.prev(node):Node` - Predecessor node
-* `tree.next(node):Node` - Successor node
-* `tree.load(keys:Array<*>, [values:Array<*>][,presort=false]):Tree` - Bulk-load items. It expects values and keys to be sorted, but if `presort` is `true`, it will sort keys and values using the comparator(in-place, your arrays are going to be altered).
+- `new SplayTree([comparator])`, where `comparator` is optional comparison function
+- `tree.insert(key:any, [data:any]):Node` - Insert item, allow duplicate keys
+- `tree.add(key:any, [data:any]):Node` - Insert item if it is not present
+- `tree.remove(key:any)` - Remove item
+- `tree.find(key):Node|Null` - Return node by its key
+- `tree.findStatic(key):Node|Null` - Return node by its key (doesn't re-balance the tree)
+- `tree.at(index:Number):Node|Null` - Return node by its index in sorted order of keys
+- `tree.contains(key):Boolean` - Whether a node with the given key is in the tree
+- `tree.forEach(function(node) {...}):Tree` In-order traversal
+- `tree.keys():Array<key>` - Returns the array of keys in order
+- `tree.values():Array<*>` - Returns the array of data fields in order
+- `tree.range(lo, high, function(node) {} [, context]):Tree` - Walks the range of keys in order. Stops, if the visitor function returns a non-zero value.
+- `tree.pop():Node` - Removes smallest node
+- `tree.min():key` - Returns min key
+- `tree.max():key` - Returns max key
+- `tree.minNode():Node` - Returns the node with smallest key
+- `tree.maxNode():Node` - Returns the node with highest key
+- `tree.prev(node):Node` - Predecessor node
+- `tree.next(node):Node` - Successor node
+- `tree.load(keys:Array<*>, [values:Array<*>][,presort=false]):Tree` - Bulk-load items. It expects values and keys to be sorted, but if `presort` is `true`, it will sort keys and values using the comparator(in-place, your arrays are going to be altered).
 
 **Comparator**
 
 `function(a:key,b:key):Number` - Comparator function between two keys, it returns
- * `0` if the keys are equal
- * `<0` if `a < b`
- * `>0` if `a > b`
 
- The comparator function is extremely important, in case of errors you might end
- up with a wrongly constructed tree or would not be able to retrieve your items.
- It is crucial to test the return values of your `comparator(a,b)` and `comparator(b,a)`
- to make sure it's working correctly, otherwise you may have bugs that are very
- unpredictable and hard to catch.
+- `0` if the keys are equal
+- `<0` if `a < b`
+- `>0` if `a > b`
+
+The comparator function is extremely important, in case of errors you might end
+up with a wrongly constructed tree or would not be able to retrieve your items.
+It is crucial to test the return values of your `comparator(a,b)` and `comparator(b,a)`
+to make sure it's working correctly, otherwise you may have bugs that are very
+unpredictable and hard to catch.
 
- **Duplicate keys**
+**Duplicate keys**
 
-* `insert()` method allows duplicate keys. This can be useful in certain applications (example: overlapping
- points in 2D).
-* `add()` method will not allow duplicate keys - if key is already present in the tree, no new node is created
+- `insert()` method allows duplicate keys. This can be useful in certain applications (example: overlapping
+  points in 2D).
+- `add()` method will not allow duplicate keys - if key is already present in the tree, no new node is created
 
 ## Example
 
 ```js
-import Tree from 'splaytree';
+import Tree from "splaytree";
 
 const t = new Tree();
 t.insert(5);
@@ -99,18 +101,18 @@ t.insert(33);
 t.insert(2);
 
 console.log(t.keys()); // [-10, 0, 2, 5, 33]
-console.log(t.size);   // 5
-console.log(t.min());  // -10
-console.log(t.max());  // -33
+console.log(t.size); // 5
+console.log(t.min()); // -10
+console.log(t.max()); // -33
 
 t.remove(0);
-console.log(t.size);   // 4
+console.log(t.size); // 4
 ```
 
 **Custom comparator (reverse sort)**
 
 ```js
-import Tree from 'splaytree';
+import Tree from "splaytree";
 
 const t = new Tree((a, b) => b - a);
 t.insert(5);
@@ -125,11 +127,11 @@ console.log(t.keys()); // [33, 5, 2, 0, -10]
 **Bulk insert**
 
 ```js
-import Tree from 'splaytree';
+import Tree from "splaytree";
 
 const t = new Tree();
-t.load([3,2,-10,20], ['C', 'B', 'A', 'D']);
-console.log(t.keys());   // [-10, 2, 3, 20]
+t.load([3, 2, -10, 20], ["C", "B", "A", "D"]);
+console.log(t.keys()); // [-10, 2, 3, 20]
 console.log(t.values()); // ['A', 'B', 'C', 'D']
 ```
 
@@ -196,7 +198,6 @@ npm run build
 
 - [ ] try and add parent fields for efficient `.prev()` and `.next()`, or iterators
 
-
 ## License
 
 The MIT License (MIT)

package/node_modules/splaytree/dist/splay.esm.js

@@ -1,5 +1,5 @@
 /**
- * splaytree v3.1.1
+ * splaytree v3.1.2
  * Fast Splay tree for Node and browser
  *
  * @author Alexander Milevski <info@w8r.name>
@@ -542,20 +542,33 @@ var Tree = /** @class */ (function () {
         return split(key, this._root, this._comparator);
     };
     Tree.prototype[Symbol.iterator] = function () {
-        var n;
+        var current, Q, done;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    n = this.minNode();
+                    current = this._root;
+                    Q = [];
+                    done = false;
                     _a.label = 1;
                 case 1:
-                    if (!n) return [3 /*break*/, 3];
-                    return [4 /*yield*/, n];
+                    if (!!done) return [3 /*break*/, 6];
+                    if (!(current !== null)) return [3 /*break*/, 2];
+                    Q.push(current);
+                    current = current.left;
+                    return [3 /*break*/, 5];
                 case 2:
+                    if (!(Q.length !== 0)) return [3 /*break*/, 4];
+                    current = Q.pop();
+                    return [4 /*yield*/, current];
+                case 3:
                     _a.sent();
-                    n = this.next(n);
-                    return [3 /*break*/, 1];
-                case 3: return [2 /*return*/];
+                    current = current.right;
+                    return [3 /*break*/, 5];
+                case 4:
+                    done = true;
+                    _a.label = 5;
+                case 5: return [3 /*break*/, 1];
+                case 6: return [2 /*return*/];
             }
         });
     };

package/node_modules/splaytree/dist/splay.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"splay.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"splay.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/node_modules/splaytree/dist/splay.js

@@ -1,5 +1,5 @@
 /**
- * splaytree v3.1.1
+ * splaytree v3.1.2
  * Fast Splay tree for Node and browser
  *
  * @author Alexander Milevski <info@w8r.name>
@@ -548,20 +548,33 @@
             return split(key, this._root, this._comparator);
         };
         Tree.prototype[Symbol.iterator] = function () {
-            var n;
+            var current, Q, done;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        n = this.minNode();
+                        current = this._root;
+                        Q = [];
+                        done = false;
                         _a.label = 1;
                     case 1:
-                        if (!n) return [3 /*break*/, 3];
-                        return [4 /*yield*/, n];
+                        if (!!done) return [3 /*break*/, 6];
+                        if (!(current !== null)) return [3 /*break*/, 2];
+                        Q.push(current);
+                        current = current.left;
+                        return [3 /*break*/, 5];
                     case 2:
+                        if (!(Q.length !== 0)) return [3 /*break*/, 4];
+                        current = Q.pop();
+                        return [4 /*yield*/, current];
+                    case 3:
                         _a.sent();
-                        n = this.next(n);
-                        return [3 /*break*/, 1];
-                    case 3: return [2 /*return*/];
+                        current = current.right;
+                        return [3 /*break*/, 5];
+                    case 4:
+                        done = true;
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/];
                 }
             });
         };

package/node_modules/splaytree/dist/splay.js.map

@@ -1 +1 @@
-{"version":3,"file":"splay.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"splay.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/node_modules/splaytree/package.json

@@ -1,39 +1,41 @@
 {
-  "_from": "splaytree@^3.1.0",
-  "_id": "splaytree@3.1.1",
-  "_inBundle": false,
-  "_integrity": "sha512-9FaQ18FF0+sZc/ieEeXHt+Jw2eSpUgUtTLDYB/HXKWvhYVyOc7h1hzkn5MMO3GPib9MmXG1go8+OsBBzs/NMww==",
-  "_location": "/splaytree",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "splaytree@^3.1.0",
-    "name": "splaytree",
-    "escapedName": "splaytree",
-    "rawSpec": "^3.1.0",
-    "saveSpec": null,
-    "fetchSpec": "^3.1.0"
-  },
-  "_requiredBy": [
-    "/polygon-clipping"
+  "name": "splaytree",
+  "version": "3.1.2",
+  "author": "Alexander Milevski <info@w8r.name>",
+  "license": "MIT",
+  "description": "Fast Splay tree for Node and browser",
+  "main": "dist/splay.js",
+  "browser": "dist/splay.js",
+  "unpkg": "dist/splay.js",
+  "module": "dist/splay.esm.js",
+  "types": "typings/index.d.ts",
+  "files": [
+    "dist",
+    "typings",
+    "src"
   ],
-  "_resolved": "https://registry.npmjs.org/splaytree/-/splaytree-3.1.1.tgz",
-  "_shasum": "e1bc8e68e64ef5a9d5f09d36e6d9f3621795a438",
-  "_spec": "splaytree@^3.1.0",
-  "_where": "/Users/conway/Projects/TAKreg/node_modules/polygon-clipping",
-  "author": {
-    "name": "Alexander Milevski",
-    "email": "info@w8r.name"
+  "directories": {
+    "test": "test",
+    "typings": "typings"
   },
-  "browser": "dist/splay.js",
-  "bugs": {
-    "url": "https://github.com/w8r/splay-tree/issues"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/w8r/splay-tree.git"
+  },
+  "scripts": {
+    "lint": "tslint --project tsconfig.json ./src/*.ts",
+    "build": "rollup -c && npm run types",
+    "types": "tsc --declaration --emitDeclarationOnly",
+    "prebenchmark": "npm run build",
+    "benchmark": "node -r reify bench/benchmark.js",
+    "start": "npm run test:watch",
+    "test:watch": "nodemon --watch index.js --watch tests --exec 'npm test'",
+    "test": "nyc mocha tests/**/*.test.ts",
+    "posttest": "nyc report --reporter=json",
+    "prepublishOnly": "npm run build && npm test",
+    "clean": "rm -rf dist coverage .nyc",
+    "coverage": "codecov -f coverage/*.json"
   },
-  "bundleDependencies": false,
-  "dependencies": {},
-  "deprecated": false,
-  "description": "Fast Splay tree for Node and browser",
   "devDependencies": {
     "@types/chai": "^4.1.4",
     "@types/mocha": "^5.2.2",
@@ -43,7 +45,7 @@
     "chai": "^4.2.0",
     "codecov": "^3.8.3",
     "mocha": "^6.2.0",
-    "nodemon": "^1.19.2",
+    "nodemon": "^2.0.20",
     "nyc": "^14.1.1",
     "reify": "*",
     "rollup": "*",
@@ -53,16 +55,6 @@
     "tslint": "^5.14.0",
     "typescript": "^2.9.2"
   },
-  "directories": {
-    "test": "test",
-    "typings": "typings"
-  },
-  "files": [
-    "dist",
-    "typings",
-    "src"
-  ],
-  "homepage": "https://github.com/w8r/splay-tree#readme",
   "keywords": [
     "binary-tree",
     "bst",
@@ -70,15 +62,11 @@
     "splay",
     "balanced-search-tree"
   ],
-  "license": "MIT",
-  "main": "dist/splay.js",
   "mocha": {
     "require": [
       "ts-node/register"
     ]
   },
-  "module": "dist/splay.esm.js",
-  "name": "splaytree",
   "nyc": {
     "include": [
       "src/*.ts"
@@ -99,25 +87,5 @@
     "sourceMap": true,
     "instrument": true
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/w8r/splay-tree.git"
-  },
-  "scripts": {
-    "benchmark": "node -r reify bench/benchmark.js",
-    "build": "rollup -c && npm run types",
-    "clean": "rm -rf dist coverage .nyc",
-    "coverage": "codecov -f coverage/*.json",
-    "lint": "tslint --project tsconfig.json ./src/*.ts",
-    "posttest": "nyc report --reporter=json",
-    "prebenchmark": "npm run build",
-    "prepublishOnly": "npm run build && npm test",
-    "start": "npm run test:watch",
-    "test": "nyc mocha tests/**/*.test.ts",
-    "test:watch": "nodemon --watch index.js --watch tests --exec 'npm test'",
-    "types": "tsc --declaration --emitDeclarationOnly"
-  },
-  "types": "typings/index.d.ts",
-  "unpkg": "dist/splay.js",
-  "version": "3.1.1"
+  "dependencies": {}
 }

package/node_modules/splaytree/src/index.ts

@@ -531,10 +531,22 @@ export default class Tree<Key=number, Value=any> {
   }
 
   *[Symbol.iterator]() {
-    let n = this.minNode();
-    while (n) {
-      yield n;
-      n = this.next(n);
+    let current = this._root;
+    const Q: Node<Key, Value>[] = [];  /* Initialize stack s */
+    let done = false;
+
+    while (!done) {
+      if (current !==  null) {
+        Q.push(current);
+        current = current.left;
+      } else {
+        if (Q.length !== 0) {
+          current = Q.pop()!;
+          yield current;
+
+          current = current.right;
+        } else done = true;
+      }
     }
   }
 }

package/node_modules/tinyqueue/package.json

@@ -1,45 +1,20 @@
 {
-  "_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,
+  "name": "tinyqueue",
+  "version": "2.0.3",
   "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"
+  "main": "tinyqueue.js",
+  "module": "index.js",
+  "jsdelivr": "tinyqueue.min.js",
+  "unpkg": "tinyqueue.min.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "lint": "eslint index.js test.js bench.js rollup.config.js",
+    "pretest": "npm run lint",
+    "test": "tape -r esm test.js",
+    "bench": "node -r esm bench.js",
+    "build": "rollup -c",
+    "watch": "rollup -cw",
+    "prepublishOnly": "npm test"
   },
   "files": [
     "index.js",
@@ -47,32 +22,32 @@
     "tinyqueue.min.js",
     "index.d.ts"
   ],
-  "homepage": "https://github.com/mourner/tinyqueue",
-  "jsdelivr": "tinyqueue.min.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mourner/tinyqueue.git"
+  },
   "keywords": [
     "queue",
     "priority",
     "binary heap",
     "data structures"
   ],
+  "author": "",
   "license": "ISC",
-  "main": "tinyqueue.js",
-  "module": "index.js",
-  "name": "tinyqueue",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mourner/tinyqueue.git"
+  "bugs": {
+    "url": "https://github.com/mourner/tinyqueue/issues"
   },
-  "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"
+  "homepage": "https://github.com/mourner/tinyqueue",
+  "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"
   },
-  "types": "index.d.ts",
-  "unpkg": "tinyqueue.min.js",
-  "version": "2.0.3"
+  "eslintConfig": {
+    "extends": "mourner"
+  }
 }