articulated 1.3.1 → 1.3.2

package/build/commonjs/vendor/functional-red-black-tree.js

@@ -1,495 +1,348 @@
 "use strict";
-module.exports = createRBTree;
 // Modified from https://github.com/mikolalysenko/functional-red-black-tree/blob/master/rbtree.js
 // which is MIT Licensed, Copyright (c) 2013 Mikola Lysenko.
-var RED = 0;
-var BLACK = 1;
-function RBNode(color, key, value, left, right) {
-    this._color = color;
-    this.key = key;
-    this.value = value;
-    this.left = left;
-    this.right = right;
+//
+// External types modified from
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/functional-red-black-tree/functional-red-black-tree-tests.ts
+// which is MIT Licensed.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedBlackTreeIterator = exports.RedBlackTree = exports.RBNode = void 0;
+const RED = 0;
+const BLACK = 1;
+/**
+ * @private Only exported for tests.
+ */
+class RBNode {
+    constructor(color, 
+    /** The key associated with the node. */
+    key, 
+    /** The value associated with the node. */
+    value, 
+    /** The left subtree of the node. */
+    left, 
+    /** The right subtree of the node. */
+    right) {
+        this.color = color;
+        this.key = key;
+        this.value = value;
+        this.left = left;
+        this.right = right;
+    }
 }
+exports.RBNode = RBNode;
 function cloneNode(node) {
-    return new RBNode(node._color, node.key, node.value, node.left, node.right);
+    return new RBNode(node.color, node.key, node.value, node.left, node.right);
 }
 function repaint(color, node) {
     return new RBNode(color, node.key, node.value, node.left, node.right);
 }
-function RedBlackTree(compare, root) {
-    this._compare = compare;
-    this.root = root;
-}
-var proto = RedBlackTree.prototype;
-// Object.defineProperty(proto, "keys", {
-//   get: function () {
-//     var result = [];
-//     this.forEach(function (k, v) {
-//       result.push(k);
-//     });
-//     return result;
-//   },
-// });
-// Object.defineProperty(proto, "values", {
-//   get: function () {
-//     var result = [];
-//     this.forEach(function (k, v) {
-//       result.push(v);
-//     });
-//     return result;
-//   },
-// });
-//Set a key-value pair
-proto.set = function (key, value) {
-    var cmp = this._compare;
-    //Find point to insert/replace node
-    var n = this.root;
-    var n_stack = [];
-    var d_stack = [];
-    let d = 0;
-    while (n) {
-        d = cmp(key, n.key);
-        n_stack.push(n);
-        d_stack.push(d);
-        // If the keys are equivalent, skip straight to the replace = true case.
-        if (d === 0)
-            break;
-        else if (d < 0) {
-            n = n.left;
-        }
-        else {
-            n = n.right;
-        }
+/** Represents a functional red-black tree. */
+class RedBlackTree {
+    constructor(compare, root) {
+        this.compare = compare;
+        this.root = root;
     }
-    const replace = d === 0 && n_stack.length > 0;
-    if (replace) {
-        // The last node in the n_stack has key equivalent to `key`.
-        // Replace its entry without changing the tree structure.
-        const lastN = n_stack[n_stack.length - 1];
-        if (lastN.key === key && lastN.value === value)
-            return this;
-        n_stack[n_stack.length - 1] = new RBNode(lastN._color, key, value, lastN.left, lastN.right);
+    /**
+     * Creates an empty red-black tree.
+     *
+     * @param compare Comparison function, same semantics as array.sort().
+     * @returns An empty tree ordered by `compare`.
+     */
+    static new(compare) {
+        return new RedBlackTree(compare, null);
     }
-    else {
-        n_stack.push(new RBNode(RED, key, value, null, null));
-    }
-    //Rebuild path to leaf node
-    for (var s = n_stack.length - 2; s >= 0; --s) {
-        var n = n_stack[s];
-        if (d_stack[s] <= 0) {
-            n_stack[s] = new RBNode(n._color, n.key, n.value, n_stack[s + 1], n.right);
+    /**
+     * Creates a new tree with `key` set to `value`, overwriting any
+     * existing value.
+     *
+     * @param key The key of the item to insert.
+     * @param value The value of the item to insert.
+     * @returns A new tree with `key` set to `value`.
+     */
+    set(key, value) {
+        const cmp = this.compare;
+        //Find point to insert/replace node
+        let n = this.root;
+        const n_stack = [];
+        const d_stack = [];
+        let d = 0;
+        while (n) {
+            d = cmp(key, n.key);
+            n_stack.push(n);
+            d_stack.push(d);
+            // If the keys are equivalent, skip straight to the replace = true case.
+            if (d === 0)
+                break;
+            else if (d < 0) {
+                n = n.left;
+            }
+            else {
+                n = n.right;
+            }
         }
-        else {
-            n_stack[s] = new RBNode(n._color, n.key, n.value, n.left, n_stack[s + 1]);
+        const replace = d === 0 && n_stack.length > 0;
+        if (replace) {
+            // The last node in the n_stack has key equivalent to `key`.
+            // Replace its entry without changing the tree structure.
+            const lastN = n_stack[n_stack.length - 1];
+            if (lastN.key === key && lastN.value === value)
+                return this;
+            n_stack[n_stack.length - 1] = new RBNode(lastN.color, key, value, lastN.left, lastN.right);
         }
-    }
-    if (replace)
-        return new RedBlackTree(cmp, n_stack[0]);
-    //Rebalance tree using rotations
-    //console.log("start insert", key, d_stack)
-    for (var s = n_stack.length - 1; s > 1; --s) {
-        var p = n_stack[s - 1];
-        var n = n_stack[s];
-        if (p._color === BLACK || n._color === BLACK) {
-            break;
+        else {
+            n_stack.push(new RBNode(RED, key, value, null, null));
         }
-        var pp = n_stack[s - 2];
-        if (pp.left === p) {
-            if (p.left === n) {
-                var y = pp.right;
-                if (y && y._color === RED) {
-                    //console.log("LLr")
-                    p._color = BLACK;
-                    pp.right = repaint(BLACK, y);
-                    pp._color = RED;
-                    s -= 1;
-                }
-                else {
-                    //console.log("LLb")
-                    pp._color = RED;
-                    pp.left = p.right;
-                    p._color = BLACK;
-                    p.right = pp;
-                    n_stack[s - 2] = p;
-                    n_stack[s - 1] = n;
-                    if (s >= 3) {
-                        var ppp = n_stack[s - 3];
-                        if (ppp.left === pp) {
-                            ppp.left = p;
-                        }
-                        else {
-                            ppp.right = p;
-                        }
-                    }
-                    break;
-                }
+        //Rebuild path to leaf node
+        let s;
+        for (s = n_stack.length - 2; s >= 0; --s) {
+            n = n_stack[s];
+            if (d_stack[s] <= 0) {
+                n_stack[s] = new RBNode(n.color, n.key, n.value, n_stack[s + 1], n.right);
             }
             else {
-                var y = pp.right;
-                if (y && y._color === RED) {
-                    //console.log("LRr")
-                    p._color = BLACK;
-                    pp.right = repaint(BLACK, y);
-                    pp._color = RED;
-                    s -= 1;
-                }
-                else {
-                    //console.log("LRb")
-                    p.right = n.left;
-                    pp._color = RED;
-                    pp.left = n.right;
-                    n._color = BLACK;
-                    n.left = p;
-                    n.right = pp;
-                    n_stack[s - 2] = n;
-                    n_stack[s - 1] = p;
-                    if (s >= 3) {
-                        var ppp = n_stack[s - 3];
-                        if (ppp.left === pp) {
-                            ppp.left = n;
-                        }
-                        else {
-                            ppp.right = n;
-                        }
-                    }
-                    break;
-                }
+                n_stack[s] = new RBNode(n.color, n.key, n.value, n.left, n_stack[s + 1]);
             }
         }
-        else {
-            if (p.right === n) {
-                var y = pp.left;
-                if (y && y._color === RED) {
-                    //console.log("RRr", y.key)
-                    p._color = BLACK;
-                    pp.left = repaint(BLACK, y);
-                    pp._color = RED;
-                    s -= 1;
+        if (replace)
+            return new RedBlackTree(cmp, n_stack[0]);
+        //Rebalance tree using rotations
+        //console.log("start insert", key, d_stack)
+        for (s = n_stack.length - 1; s > 1; --s) {
+            const p = n_stack[s - 1];
+            n = n_stack[s];
+            if (p.color === BLACK || n.color === BLACK) {
+                break;
+            }
+            const pp = n_stack[s - 2];
+            if (pp.left === p) {
+                if (p.left === n) {
+                    const y = pp.right;
+                    if (y && y.color === RED) {
+                        //console.log("LLr")
+                        p.color = BLACK;
+                        pp.right = repaint(BLACK, y);
+                        pp.color = RED;
+                        s -= 1;
+                    }
+                    else {
+                        //console.log("LLb")
+                        pp.color = RED;
+                        pp.left = p.right;
+                        p.color = BLACK;
+                        p.right = pp;
+                        n_stack[s - 2] = p;
+                        n_stack[s - 1] = n;
+                        if (s >= 3) {
+                            const ppp = n_stack[s - 3];
+                            if (ppp.left === pp) {
+                                ppp.left = p;
+                            }
+                            else {
+                                ppp.right = p;
+                            }
+                        }
+                        break;
+                    }
                 }
                 else {
-                    //console.log("RRb")
-                    pp._color = RED;
-                    pp.right = p.left;
-                    p._color = BLACK;
-                    p.left = pp;
-                    n_stack[s - 2] = p;
-                    n_stack[s - 1] = n;
-                    if (s >= 3) {
-                        var ppp = n_stack[s - 3];
-                        if (ppp.right === pp) {
-                            ppp.right = p;
-                        }
-                        else {
-                            ppp.left = p;
+                    const y = pp.right;
+                    if (y && y.color === RED) {
+                        //console.log("LRr")
+                        p.color = BLACK;
+                        pp.right = repaint(BLACK, y);
+                        pp.color = RED;
+                        s -= 1;
+                    }
+                    else {
+                        //console.log("LRb")
+                        p.right = n.left;
+                        pp.color = RED;
+                        pp.left = n.right;
+                        n.color = BLACK;
+                        n.left = p;
+                        n.right = pp;
+                        n_stack[s - 2] = n;
+                        n_stack[s - 1] = p;
+                        if (s >= 3) {
+                            const ppp = n_stack[s - 3];
+                            if (ppp.left === pp) {
+                                ppp.left = n;
+                            }
+                            else {
+                                ppp.right = n;
+                            }
                         }
+                        break;
                     }
-                    break;
                 }
             }
             else {
-                var y = pp.left;
-                if (y && y._color === RED) {
-                    //console.log("RLr")
-                    p._color = BLACK;
-                    pp.left = repaint(BLACK, y);
-                    pp._color = RED;
-                    s -= 1;
+                if (p.right === n) {
+                    const y = pp.left;
+                    if (y && y.color === RED) {
+                        //console.log("RRr", y.key)
+                        p.color = BLACK;
+                        pp.left = repaint(BLACK, y);
+                        pp.color = RED;
+                        s -= 1;
+                    }
+                    else {
+                        //console.log("RRb")
+                        pp.color = RED;
+                        pp.right = p.left;
+                        p.color = BLACK;
+                        p.left = pp;
+                        n_stack[s - 2] = p;
+                        n_stack[s - 1] = n;
+                        if (s >= 3) {
+                            const ppp = n_stack[s - 3];
+                            if (ppp.right === pp) {
+                                ppp.right = p;
+                            }
+                            else {
+                                ppp.left = p;
+                            }
+                        }
+                        break;
+                    }
                 }
                 else {
-                    //console.log("RLb")
-                    p.left = n.right;
-                    pp._color = RED;
-                    pp.right = n.left;
-                    n._color = BLACK;
-                    n.right = p;
-                    n.left = pp;
-                    n_stack[s - 2] = n;
-                    n_stack[s - 1] = p;
-                    if (s >= 3) {
-                        var ppp = n_stack[s - 3];
-                        if (ppp.right === pp) {
-                            ppp.right = n;
-                        }
-                        else {
-                            ppp.left = n;
+                    const y = pp.left;
+                    if (y && y.color === RED) {
+                        //console.log("RLr")
+                        p.color = BLACK;
+                        pp.left = repaint(BLACK, y);
+                        pp.color = RED;
+                        s -= 1;
+                    }
+                    else {
+                        //console.log("RLb")
+                        p.left = n.right;
+                        pp.color = RED;
+                        pp.right = n.left;
+                        n.color = BLACK;
+                        n.right = p;
+                        n.left = pp;
+                        n_stack[s - 2] = n;
+                        n_stack[s - 1] = p;
+                        if (s >= 3) {
+                            const ppp = n_stack[s - 3];
+                            if (ppp.right === pp) {
+                                ppp.right = n;
+                            }
+                            else {
+                                ppp.left = n;
+                            }
                         }
+                        break;
                     }
-                    break;
                 }
             }
         }
+        //Return new tree
+        n_stack[0].color = BLACK;
+        return new RedBlackTree(cmp, n_stack[0]);
     }
-    //Return new tree
-    n_stack[0]._color = BLACK;
-    return new RedBlackTree(cmp, n_stack[0]);
-};
-// //Visit all nodes inorder
-// function doVisitFull(visit, node) {
-//   if (node.left) {
-//     var v = doVisitFull(visit, node.left);
-//     if (v) {
-//       return v;
-//     }
-//   }
-//   var v = visit(node.key, node.value);
-//   if (v) {
-//     return v;
-//   }
-//   if (node.right) {
-//     return doVisitFull(visit, node.right);
-//   }
-// }
-// //Visit half nodes in order
-// function doVisitHalf(lo, compare, visit, node) {
-//   var l = compare(lo, node.key);
-//   if (l <= 0) {
-//     if (node.left) {
-//       var v = doVisitHalf(lo, compare, visit, node.left);
-//       if (v) {
-//         return v;
-//       }
-//     }
-//     var v = visit(node.key, node.value);
-//     if (v) {
-//       return v;
-//     }
-//   }
-//   if (node.right) {
-//     return doVisitHalf(lo, compare, visit, node.right);
-//   }
-// }
-// //Visit all nodes within a range
-// function doVisit(lo, hi, compare, visit, node) {
-//   var l = compare(lo, node.key);
-//   var h = compare(hi, node.key);
-//   var v;
-//   if (l <= 0) {
-//     if (node.left) {
-//       v = doVisit(lo, hi, compare, visit, node.left);
-//       if (v) {
-//         return v;
-//       }
-//     }
-//     if (h > 0) {
-//       v = visit(node.key, node.value);
-//       if (v) {
-//         return v;
-//       }
-//     }
-//   }
-//   if (h > 0 && node.right) {
-//     return doVisit(lo, hi, compare, visit, node.right);
-//   }
-// }
-// proto.forEach = function rbTreeForEach(visit, lo, hi) {
-//   if (!this.root) {
-//     return;
-//   }
-//   switch (arguments.length) {
-//     case 1:
-//       return doVisitFull(visit, this.root);
-//       break;
-//     case 2:
-//       return doVisitHalf(lo, this._compare, visit, this.root);
-//       break;
-//     case 3:
-//       if (this._compare(lo, hi) >= 0) {
-//         return;
-//       }
-//       return doVisit(lo, hi, this._compare, visit, this.root);
-//       break;
-//   }
-// };
-// //First item in list
-// Object.defineProperty(proto, "begin", {
-//   get: function () {
-//     var stack = [];
-//     var n = this.root;
-//     while (n) {
-//       stack.push(n);
-//       n = n.left;
-//     }
-//     return new RedBlackTreeIterator(this, stack);
-//   },
-// });
-// //Last item in list
-// Object.defineProperty(proto, "end", {
-//   get: function () {
-//     var stack = [];
-//     var n = this.root;
-//     while (n) {
-//       stack.push(n);
-//       n = n.right;
-//     }
-//     return new RedBlackTreeIterator(this, stack);
-//   },
-// });
-// proto.ge = function (key) {
-//   var cmp = this._compare;
-//   var n = this.root;
-//   var stack = [];
-//   var last_ptr = 0;
-//   while (n) {
-//     var d = cmp(key, n.key);
-//     stack.push(n);
-//     if (d <= 0) {
-//       last_ptr = stack.length;
-//     }
-//     if (d <= 0) {
-//       n = n.left;
-//     } else {
-//       n = n.right;
-//     }
-//   }
-//   stack.length = last_ptr;
-//   return new RedBlackTreeIterator(this, stack);
-// };
-// proto.gt = function (key) {
-//   var cmp = this._compare;
-//   var n = this.root;
-//   var stack = [];
-//   var last_ptr = 0;
-//   while (n) {
-//     var d = cmp(key, n.key);
-//     stack.push(n);
-//     if (d < 0) {
-//       last_ptr = stack.length;
-//     }
-//     if (d < 0) {
-//       n = n.left;
-//     } else {
-//       n = n.right;
-//     }
-//   }
-//   stack.length = last_ptr;
-//   return new RedBlackTreeIterator(this, stack);
-// };
-// proto.lt = function (key) {
-//   var cmp = this._compare;
-//   var n = this.root;
-//   var stack = [];
-//   var last_ptr = 0;
-//   while (n) {
-//     var d = cmp(key, n.key);
-//     stack.push(n);
-//     if (d > 0) {
-//       last_ptr = stack.length;
-//     }
-//     if (d <= 0) {
-//       n = n.left;
-//     } else {
-//       n = n.right;
-//     }
-//   }
-//   stack.length = last_ptr;
-//   return new RedBlackTreeIterator(this, stack);
-// };
-proto.le = function (key) {
-    var cmp = this._compare;
-    var n = this.root;
-    var stack = [];
-    var last_ptr = 0;
-    while (n) {
-        var d = cmp(key, n.key);
-        stack.push(n);
-        if (d >= 0) {
-            last_ptr = stack.length;
-        }
-        if (d < 0) {
-            n = n.left;
-        }
-        else {
-            n = n.right;
+    /**
+     * Finds the last item in the tree whose key is <= `key`.
+     *
+     * @param key The key to search for.
+     * @returns An iterator at the given element.
+     */
+    le(key) {
+        const cmp = this.compare;
+        let n = this.root;
+        const stack = [];
+        let last_ptr = 0;
+        while (n) {
+            const d = cmp(key, n.key);
+            stack.push(n);
+            if (d >= 0) {
+                last_ptr = stack.length;
+            }
+            if (d < 0) {
+                n = n.left;
+            }
+            else {
+                n = n.right;
+            }
         }
+        stack.length = last_ptr;
+        return new RedBlackTreeIterator(this, stack);
     }
-    stack.length = last_ptr;
-    return new RedBlackTreeIterator(this, stack);
-};
-//Finds the item with key if it exists
-proto.find = function (key) {
-    var cmp = this._compare;
-    var n = this.root;
-    var stack = [];
-    while (n) {
-        var d = cmp(key, n.key);
-        stack.push(n);
-        if (d === 0) {
-            return new RedBlackTreeIterator(this, stack);
-        }
-        if (d <= 0) {
-            n = n.left;
-        }
-        else {
-            n = n.right;
+    /**
+     * @returns An iterator pointing to the first item in the tree with `key`, otherwise null.
+     */
+    find(key) {
+        const cmp = this.compare;
+        let n = this.root;
+        const stack = [];
+        while (n) {
+            const d = cmp(key, n.key);
+            stack.push(n);
+            if (d === 0) {
+                return new RedBlackTreeIterator(this, stack);
+            }
+            if (d <= 0) {
+                n = n.left;
+            }
+            else {
+                n = n.right;
+            }
         }
+        return new RedBlackTreeIterator(this, []);
     }
-    return new RedBlackTreeIterator(this, []);
-};
-//Removes item with key from tree
-proto.remove = function (key) {
-    var iter = this.find(key);
-    return iter.remove();
-};
-//Returns the item at `key`
-proto.get = function (key) {
-    var cmp = this._compare;
-    var n = this.root;
-    while (n) {
-        var d = cmp(key, n.key);
-        if (d === 0) {
-            return n.value;
-        }
-        if (d <= 0) {
-            n = n.left;
-        }
-        else {
-            n = n.right;
+    /**
+     * Removes the first item with `key` in the tree.
+     *
+     * @param key The key of the item to remove.
+     * @returns A new tree with the given item removed, if it exists.
+     */
+    remove(key) {
+        const iter = this.find(key);
+        return iter.remove();
+    }
+    /**
+     * Retrieves the value associated with `key`.
+     *
+     * @param key The key of the item to look up.
+     * @returns The value of the first node associated with `key`.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    get(key) {
+        const cmp = this.compare;
+        let n = this.root;
+        while (n) {
+            const d = cmp(key, n.key);
+            if (d === 0) {
+                return n.value;
+            }
+            if (d <= 0) {
+                n = n.left;
+            }
+            else {
+                n = n.right;
+            }
         }
+        return;
     }
-    return;
-};
-//Iterator for red black tree
-function RedBlackTreeIterator(tree, stack) {
-    this.tree = tree;
-    this._stack = stack;
 }
-var iproto = RedBlackTreeIterator.prototype;
-// //Test if iterator is valid
-// Object.defineProperty(iproto, "valid", {
-//   get: function () {
-//     return this._stack.length > 0;
-//   },
-// });
-// //Node of the iterator
-// Object.defineProperty(iproto, "node", {
-//   get: function () {
-//     if (this._stack.length > 0) {
-//       return this._stack[this._stack.length - 1];
-//     }
-//     return null;
-//   },
-//   enumerable: true,
-// });
-// //Makes a copy of an iterator
-// iproto.clone = function () {
-//   return new RedBlackTreeIterator(this.tree, this._stack.slice());
-// };
+exports.RedBlackTree = RedBlackTree;
 //Swaps two nodes
 function swapNode(n, v) {
     n.key = v.key;
     n.value = v.value;
     n.left = v.left;
     n.right = v.right;
-    n._color = v._color;
+    n.color = v.color;
 }
 //Fix up a double black node in a tree
 function fixDoubleBlack(stack) {
-    var n, p, s, z;
-    for (var i = stack.length - 1; i >= 0; --i) {
+    let n, p, s, z;
+    for (let i = stack.length - 1; i >= 0; --i) {
         n = stack[i];
         if (i === 0) {
-            n._color = BLACK;
+            n.color = BLACK;
             return;
         }
         //console.log("visit node:", n.key, i, stack[i].key, stack[i-1].key)
@@ -497,19 +350,19 @@ function fixDoubleBlack(stack) {
         if (p.left === n) {
             //console.log("left child")
             s = p.right;
-            if (s.right && s.right._color === RED) {
+            if (s.right && s.right.color === RED) {
                 //console.log("case 1: right sibling child red")
                 s = p.right = cloneNode(s);
                 z = s.right = cloneNode(s.right);
                 p.right = s.left;
                 s.left = p;
                 s.right = z;
-                s._color = p._color;
-                n._color = BLACK;
-                p._color = BLACK;
-                z._color = BLACK;
+                s.color = p.color;
+                n.color = BLACK;
+                p.color = BLACK;
+                z.color = BLACK;
                 if (i > 1) {
-                    var pp = stack[i - 2];
+                    const pp = stack[i - 2];
                     if (pp.left === p) {
                         pp.left = s;
                     }
@@ -520,7 +373,7 @@ function fixDoubleBlack(stack) {
                 stack[i - 1] = s;
                 return;
             }
-            else if (s.left && s.left._color === RED) {
+            else if (s.left && s.left.color === RED) {
                 //console.log("case 1: left sibling child red")
                 s = p.right = cloneNode(s);
                 z = s.left = cloneNode(s.left);
@@ -528,12 +381,12 @@ function fixDoubleBlack(stack) {
                 s.left = z.right;
                 z.left = p;
                 z.right = s;
-                z._color = p._color;
-                p._color = BLACK;
-                s._color = BLACK;
-                n._color = BLACK;
+                z.color = p.color;
+                p.color = BLACK;
+                s.color = BLACK;
+                n.color = BLACK;
                 if (i > 1) {
-                    var pp = stack[i - 2];
+                    const pp = stack[i - 2];
                     if (pp.left === p) {
                         pp.left = z;
                     }
@@ -544,10 +397,10 @@ function fixDoubleBlack(stack) {
                 stack[i - 1] = z;
                 return;
             }
-            if (s._color === BLACK) {
-                if (p._color === RED) {
+            if (s.color === BLACK) {
+                if (p.color === RED) {
                     //console.log("case 2: black sibling, red parent", p.right.value)
-                    p._color = BLACK;
+                    p.color = BLACK;
                     p.right = repaint(RED, s);
                     return;
                 }
@@ -562,10 +415,10 @@ function fixDoubleBlack(stack) {
                 s = cloneNode(s);
                 p.right = s.left;
                 s.left = p;
-                s._color = p._color;
-                p._color = RED;
+                s.color = p.color;
+                p.color = RED;
                 if (i > 1) {
-                    var pp = stack[i - 2];
+                    const pp = stack[i - 2];
                     if (pp.left === p) {
                         pp.left = s;
                     }
@@ -587,19 +440,19 @@ function fixDoubleBlack(stack) {
         else {
             //console.log("right child")
             s = p.left;
-            if (s.left && s.left._color === RED) {
-                //console.log("case 1: left sibling child red", p.value, p._color)
+            if (s.left && s.left.color === RED) {
+                //console.log("case 1: left sibling child red", p.value, p.color)
                 s = p.left = cloneNode(s);
                 z = s.left = cloneNode(s.left);
                 p.left = s.right;
                 s.right = p;
                 s.left = z;
-                s._color = p._color;
-                n._color = BLACK;
-                p._color = BLACK;
-                z._color = BLACK;
+                s.color = p.color;
+                n.color = BLACK;
+                p.color = BLACK;
+                z.color = BLACK;
                 if (i > 1) {
-                    var pp = stack[i - 2];
+                    const pp = stack[i - 2];
                     if (pp.right === p) {
                         pp.right = s;
                     }
@@ -610,7 +463,7 @@ function fixDoubleBlack(stack) {
                 stack[i - 1] = s;
                 return;
             }
-            else if (s.right && s.right._color === RED) {
+            else if (s.right && s.right.color === RED) {
                 //console.log("case 1: right sibling child red")
                 s = p.left = cloneNode(s);
                 z = s.right = cloneNode(s.right);
@@ -618,12 +471,12 @@ function fixDoubleBlack(stack) {
                 s.right = z.left;
                 z.right = p;
                 z.left = s;
-                z._color = p._color;
-                p._color = BLACK;
-                s._color = BLACK;
-                n._color = BLACK;
+                z.color = p.color;
+                p.color = BLACK;
+                s.color = BLACK;
+                n.color = BLACK;
                 if (i > 1) {
-                    var pp = stack[i - 2];
+                    const pp = stack[i - 2];
                     if (pp.right === p) {
                         pp.right = z;
                     }
@@ -634,10 +487,10 @@ function fixDoubleBlack(stack) {
                 stack[i - 1] = z;
                 return;
             }
-            if (s._color === BLACK) {
-                if (p._color === RED) {
+            if (s.color === BLACK) {
+                if (p.color === RED) {
                     //console.log("case 2: black sibling, red parent")
-                    p._color = BLACK;
+                    p.color = BLACK;
                     p.left = repaint(RED, s);
                     return;
                 }
@@ -652,10 +505,10 @@ function fixDoubleBlack(stack) {
                 s = cloneNode(s);
                 p.left = s.right;
                 s.right = p;
-                s._color = p._color;
-                p._color = RED;
+                s.color = p.color;
+                p.color = RED;
                 if (i > 1) {
-                    var pp = stack[i - 2];
+                    const pp = stack[i - 2];
                     if (pp.right === p) {
                         pp.right = s;
                     }
@@ -676,236 +529,128 @@ function fixDoubleBlack(stack) {
         }
     }
 }
-//Removes item at iterator from tree
-iproto.remove = function () {
-    var stack = this._stack;
-    if (stack.length === 0) {
-        return this.tree;
-    }
-    //First copy path to node
-    var cstack = new Array(stack.length);
-    var n = stack[stack.length - 1];
-    cstack[cstack.length - 1] = new RBNode(n._color, n.key, n.value, n.left, n.right);
-    for (var i = stack.length - 2; i >= 0; --i) {
-        var n = stack[i];
-        if (n.left === stack[i + 1]) {
-            cstack[i] = new RBNode(n._color, n.key, n.value, cstack[i + 1], n.right);
-        }
-        else {
-            cstack[i] = new RBNode(n._color, n.key, n.value, n.left, cstack[i + 1]);
-        }
-    }
-    //Get node
-    n = cstack[cstack.length - 1];
-    //console.log("start remove: ", n.value)
-    //If not leaf, then swap with previous node
-    if (n.left && n.right) {
-        //console.log("moving to leaf")
-        //First walk to previous leaf
-        var split = cstack.length;
-        n = n.left;
-        while (n.right) {
-            cstack.push(n);
-            n = n.right;
-        }
-        //Copy path to leaf
-        var v = cstack[split - 1];
-        cstack.push(new RBNode(n._color, v.key, v.value, n.left, n.right));
-        cstack[split - 1].key = n.key;
-        cstack[split - 1].value = n.value;
-        //Fix up stack
-        for (var i = cstack.length - 2; i >= split; --i) {
-            n = cstack[i];
-            cstack[i] = new RBNode(n._color, n.key, n.value, n.left, cstack[i + 1]);
-        }
-        cstack[split - 1].left = cstack[split];
+/** Iterates through the nodes in a red-black tree. */
+class RedBlackTreeIterator {
+    constructor(
+    /** The tree associated with the iterator. */
+    tree, stack) {
+        this.tree = tree;
+        this.stack = stack;
     }
-    //console.log("stack=", cstack.map(function(v) { return v.value }))
-    //Remove leaf node
-    n = cstack[cstack.length - 1];
-    if (n._color === RED) {
-        //Easy case: removing red leaf
-        //console.log("RED leaf")
-        var p = cstack[cstack.length - 2];
-        if (p.left === n) {
-            p.left = null;
+    /**
+     * Removes the iterator's current item form the tree.
+     *
+     * @returns A new binary search tree with the item removed.
+     */
+    remove() {
+        const stack = this.stack;
+        if (stack.length === 0) {
+            return this.tree;
         }
-        else if (p.right === n) {
-            p.right = null;
+        //First copy path to node
+        const cstack = new Array(stack.length);
+        let n = stack[stack.length - 1];
+        cstack[cstack.length - 1] = new RBNode(n.color, n.key, n.value, n.left, n.right);
+        let i;
+        for (i = stack.length - 2; i >= 0; --i) {
+            n = stack[i];
+            if (n.left === stack[i + 1]) {
+                cstack[i] = new RBNode(n.color, n.key, n.value, cstack[i + 1], n.right);
+            }
+            else {
+                cstack[i] = new RBNode(n.color, n.key, n.value, n.left, cstack[i + 1]);
+            }
         }
-        cstack.pop();
-        return new RedBlackTree(this.tree._compare, cstack[0]);
-    }
-    else {
-        if (n.left || n.right) {
-            //Second easy case:  Single child black parent
-            //console.log("BLACK single child")
-            if (n.left) {
-                swapNode(n, n.left);
-            }
-            else if (n.right) {
-                swapNode(n, n.right);
-            }
-            //Child must be red, so repaint it black to balance color
-            n._color = BLACK;
-            return new RedBlackTree(this.tree._compare, cstack[0]);
+        //Get node
+        n = cstack[cstack.length - 1];
+        //console.log("start remove: ", n.value)
+        //If not leaf, then swap with previous node
+        if (n.left && n.right) {
+            //console.log("moving to leaf")
+            //First walk to previous leaf
+            const split = cstack.length;
+            n = n.left;
+            while (n.right) {
+                cstack.push(n);
+                n = n.right;
+            }
+            //Copy path to leaf
+            const v = cstack[split - 1];
+            cstack.push(new RBNode(n.color, v.key, v.value, n.left, n.right));
+            cstack[split - 1].key = n.key;
+            cstack[split - 1].value = n.value;
+            //Fix up stack
+            for (i = cstack.length - 2; i >= split; --i) {
+                n = cstack[i];
+                cstack[i] = new RBNode(n.color, n.key, n.value, n.left, cstack[i + 1]);
+            }
+            cstack[split - 1].left = cstack[split];
         }
-        else if (cstack.length === 1) {
-            //Third easy case: root
-            //console.log("ROOT")
-            return new RedBlackTree(this.tree._compare, null);
+        //console.log("stack=", cstack.map(function(v) { return v.value }))
+        //Remove leaf node
+        n = cstack[cstack.length - 1];
+        if (n.color === RED) {
+            //Easy case: removing red leaf
+            //console.log("RED leaf")
+            const p = cstack[cstack.length - 2];
+            if (p.left === n) {
+                p.left = null;
+            }
+            else if (p.right === n) {
+                p.right = null;
+            }
+            cstack.pop();
+            return new RedBlackTree(this.tree.compare, cstack[0]);
         }
         else {
-            //Hard case: Repaint n, and then do some nasty stuff
-            //console.log("BLACK leaf no children")
-            var parent = cstack[cstack.length - 2];
-            fixDoubleBlack(cstack);
-            //Fix up links
-            if (parent.left === n) {
-                parent.left = null;
+            if (n.left || n.right) {
+                //Second easy case:  Single child black parent
+                //console.log("BLACK single child")
+                if (n.left) {
+                    swapNode(n, n.left);
+                }
+                else if (n.right) {
+                    swapNode(n, n.right);
+                }
+                //Child must be red, so repaint it black to balance color
+                n.color = BLACK;
+                return new RedBlackTree(this.tree.compare, cstack[0]);
+            }
+            else if (cstack.length === 1) {
+                //Third easy case: root
+                //console.log("ROOT")
+                return new RedBlackTree(this.tree.compare, null);
             }
             else {
-                parent.right = null;
+                //Hard case: Repaint n, and then do some nasty stuff
+                //console.log("BLACK leaf no children")
+                const parent = cstack[cstack.length - 2];
+                fixDoubleBlack(cstack);
+                //Fix up links
+                if (parent.left === n) {
+                    parent.left = null;
+                }
+                else {
+                    parent.right = null;
+                }
             }
         }
+        return new RedBlackTree(this.tree.compare, cstack[0]);
     }
-    return new RedBlackTree(this.tree._compare, cstack[0]);
-};
-//Returns key
-Object.defineProperty(iproto, "key", {
-    get: function () {
-        if (this._stack.length > 0) {
-            return this._stack[this._stack.length - 1].key;
+    /** The key of the iterator's current item. */
+    get key() {
+        if (this.stack.length > 0) {
+            return this.stack[this.stack.length - 1].key;
         }
         return;
-    },
-    enumerable: true,
-});
-//Returns value
-Object.defineProperty(iproto, "value", {
-    get: function () {
-        if (this._stack.length > 0) {
-            return this._stack[this._stack.length - 1].value;
+    }
+    /** The value of the iterator's current item. */
+    get value() {
+        if (this.stack.length > 0) {
+            return this.stack[this.stack.length - 1].value;
         }
         return;
-    },
-    enumerable: true,
-});
-// //Advances iterator to next element in list
-// iproto.next = function () {
-//   var stack = this._stack;
-//   if (stack.length === 0) {
-//     return;
-//   }
-//   var n = stack[stack.length - 1];
-//   if (n.right) {
-//     n = n.right;
-//     while (n) {
-//       stack.push(n);
-//       n = n.left;
-//     }
-//   } else {
-//     stack.pop();
-//     while (stack.length > 0 && stack[stack.length - 1].right === n) {
-//       n = stack[stack.length - 1];
-//       stack.pop();
-//     }
-//   }
-// };
-// //Checks if iterator is at end of tree
-// Object.defineProperty(iproto, "hasNext", {
-//   get: function () {
-//     var stack = this._stack;
-//     if (stack.length === 0) {
-//       return false;
-//     }
-//     if (stack[stack.length - 1].right) {
-//       return true;
-//     }
-//     for (var s = stack.length - 1; s > 0; --s) {
-//       if (stack[s - 1].left === stack[s]) {
-//         return true;
-//       }
-//     }
-//     return false;
-//   },
-// });
-// //Update value
-// iproto.update = function (value) {
-//   var stack = this._stack;
-//   if (stack.length === 0) {
-//     throw new Error("Can't update empty node!");
-//   }
-//   var cstack = new Array(stack.length);
-//   var n = stack[stack.length - 1];
-//   cstack[cstack.length - 1] = new RBNode(
-//     n._color,
-//     n.key,
-//     value,
-//     n.left,
-//     n.right
-//   );
-//   for (var i = stack.length - 2; i >= 0; --i) {
-//     n = stack[i];
-//     if (n.left === stack[i + 1]) {
-//       cstack[i] = new RBNode(n._color, n.key, n.value, cstack[i + 1], n.right);
-//     } else {
-//       cstack[i] = new RBNode(n._color, n.key, n.value, n.left, cstack[i + 1]);
-//     }
-//   }
-//   return new RedBlackTree(this.tree._compare, cstack[0]);
-// };
-// //Moves iterator backward one element
-// iproto.prev = function () {
-//   var stack = this._stack;
-//   if (stack.length === 0) {
-//     return;
-//   }
-//   var n = stack[stack.length - 1];
-//   if (n.left) {
-//     n = n.left;
-//     while (n) {
-//       stack.push(n);
-//       n = n.right;
-//     }
-//   } else {
-//     stack.pop();
-//     while (stack.length > 0 && stack[stack.length - 1].left === n) {
-//       n = stack[stack.length - 1];
-//       stack.pop();
-//     }
-//   }
-// };
-// //Checks if iterator is at start of tree
-// Object.defineProperty(iproto, "hasPrev", {
-//   get: function () {
-//     var stack = this._stack;
-//     if (stack.length === 0) {
-//       return false;
-//     }
-//     if (stack[stack.length - 1].left) {
-//       return true;
-//     }
-//     for (var s = stack.length - 1; s > 0; --s) {
-//       if (stack[s - 1].right === stack[s]) {
-//         return true;
-//       }
-//     }
-//     return false;
-//   },
-// });
-// //Default comparison function
-// function defaultCompare(a, b) {
-//   if (a < b) {
-//     return -1;
-//   }
-//   if (a > b) {
-//     return 1;
-//   }
-//   return 0;
-// }
-//Build a tree
-function createRBTree(compare) {
-    return new RedBlackTree(compare, null);
+    }
 }
+exports.RedBlackTreeIterator = RedBlackTreeIterator;
 //# sourceMappingURL=functional-red-black-tree.js.map