data-structure-typed 1.34.7 → 1.34.9

package/dist/data-structures/binary-tree/bst.js

@@ -1,84 +1,38 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BST = exports.BSTNode = void 0;
-var types_1 = require("../../types");
-var binary_tree_1 = require("./binary-tree");
-var BSTNode = (function (_super) {
-    __extends(BSTNode, _super);
-    function BSTNode(id, val) {
-        return _super.call(this, id, val) || this;
+const types_1 = require("../../types");
+const binary_tree_1 = require("./binary-tree");
+class BSTNode extends binary_tree_1.BinaryTreeNode {
+    constructor(key, val) {
+        super(key, val);
     }
-    return BSTNode;
-}(binary_tree_1.BinaryTreeNode));
+}
 exports.BSTNode = BSTNode;
-var BST = (function (_super) {
-    __extends(BST, _super);
-    function BST(options) {
-        var _this = _super.call(this, options) || this;
-        _this._comparator = function (a, b) { return a - b; };
+class BST extends binary_tree_1.BinaryTree {
+    constructor(options) {
+        super(options);
+        this._comparator = (a, b) => a - b;
         if (options !== undefined) {
-            var comparator = options.comparator;
+            const { comparator } = options;
             if (comparator !== undefined) {
-                _this._comparator = comparator;
+                this._comparator = comparator;
             }
         }
-        return _this;
     }
-    BST.prototype.createNode = function (id, val) {
-        return new BSTNode(id, val);
-    };
-    BST.prototype.add = function (idOrNode, val) {
-        var inserted = null;
-        var newNode = null;
-        if (idOrNode instanceof BSTNode) {
-            newNode = idOrNode;
+    createNode(key, val) {
+        return new BSTNode(key, val);
+    }
+    add(keyOrNode, val) {
+        let inserted = null;
+        let newNode = null;
+        if (keyOrNode instanceof BSTNode) {
+            newNode = keyOrNode;
         }
-        else if (typeof idOrNode === 'number') {
-            newNode = this.createNode(idOrNode, val);
+        else if (typeof keyOrNode === 'number') {
+            newNode = this.createNode(keyOrNode, val);
         }
-        else if (idOrNode === null) {
+        else if (keyOrNode === null) {
             newNode = null;
         }
         if (this.root === null) {
@@ -87,18 +41,18 @@ var BST = (function (_super) {
             inserted = this.root;
         }
         else {
-            var cur = this.root;
-            var traversing = true;
+            let cur = this.root;
+            let traversing = true;
             while (traversing) {
                 if (cur !== null && newNode !== null) {
-                    if (this._compare(cur.id, newNode.id) === types_1.CP.eq) {
+                    if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
                         if (newNode) {
                             cur.val = newNode.val;
                         }
                         traversing = false;
                         inserted = cur;
                     }
-                    else if (this._compare(cur.id, newNode.id) === types_1.CP.gt) {
+                    else if (this._compare(cur.key, newNode.key) === types_1.CP.gt) {
                         if (cur.left === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
@@ -113,7 +67,7 @@ var BST = (function (_super) {
                                 cur = cur.left;
                         }
                     }
-                    else if (this._compare(cur.id, newNode.id) === types_1.CP.lt) {
+                    else if (this._compare(cur.key, newNode.key) === types_1.CP.lt) {
                         if (cur.right === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
@@ -135,92 +89,60 @@ var BST = (function (_super) {
             }
         }
         return inserted;
-    };
-    BST.prototype.addMany = function (idsOrNodes, data, isBalanceAdd) {
-        var _this = this;
-        if (isBalanceAdd === void 0) { isBalanceAdd = false; }
+    }
+    addMany(keysOrNodes, data, isBalanceAdd = false) {
         function hasNoNull(arr) {
             return arr.indexOf(null) === -1;
         }
-        if (!isBalanceAdd || !hasNoNull(idsOrNodes)) {
-            return _super.prototype.addMany.call(this, idsOrNodes, data);
+        if (!isBalanceAdd || !hasNoNull(keysOrNodes)) {
+            return super.addMany(keysOrNodes, data);
         }
-        var inserted = [];
-        var combinedArr = idsOrNodes.map(function (value, index) { return [value, data === null || data === void 0 ? void 0 : data[index]]; });
-        var sorted = [];
+        const inserted = [];
+        const combinedArr = keysOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
+        let sorted = [];
         function isNodeOrNullTuple(arr) {
-            var e_1, _a;
-            try {
-                for (var arr_1 = __values(arr), arr_1_1 = arr_1.next(); !arr_1_1.done; arr_1_1 = arr_1.next()) {
-                    var _b = __read(arr_1_1.value, 1), idOrNode = _b[0];
-                    if (idOrNode instanceof BSTNode)
-                        return true;
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (arr_1_1 && !arr_1_1.done && (_a = arr_1.return)) _a.call(arr_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
+            for (const [keyOrNode] of arr)
+                if (keyOrNode instanceof BSTNode)
+                    return true;
             return false;
         }
-        function isBinaryTreeIdOrNullTuple(arr) {
-            var e_2, _a;
-            try {
-                for (var arr_2 = __values(arr), arr_2_1 = arr_2.next(); !arr_2_1.done; arr_2_1 = arr_2.next()) {
-                    var _b = __read(arr_2_1.value, 1), idOrNode = _b[0];
-                    if (typeof idOrNode === 'number')
-                        return true;
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (arr_2_1 && !arr_2_1.done && (_a = arr_2.return)) _a.call(arr_2);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
+        function isBinaryTreeKeyOrNullTuple(arr) {
+            for (const [keyOrNode] of arr)
+                if (typeof keyOrNode === 'number')
+                    return true;
             return false;
         }
-        var sortedIdsOrNodes = [], sortedData = [];
+        let sortedKeysOrNodes = [], sortedData = [];
         if (isNodeOrNullTuple(combinedArr)) {
-            sorted = combinedArr.sort(function (a, b) { return a[0].id - b[0].id; });
+            sorted = combinedArr.sort((a, b) => a[0].key - b[0].key);
         }
-        else if (isBinaryTreeIdOrNullTuple(combinedArr)) {
-            sorted = combinedArr.sort(function (a, b) { return a[0] - b[0]; });
+        else if (isBinaryTreeKeyOrNullTuple(combinedArr)) {
+            sorted = combinedArr.sort((a, b) => a[0] - b[0]);
         }
         else {
-            throw new Error('Invalid input idsOrNodes');
+            throw new Error('Invalid input keysOrNodes');
         }
-        sortedIdsOrNodes = sorted.map(function (_a) {
-            var _b = __read(_a, 1), idOrNode = _b[0];
-            return idOrNode;
-        });
-        sortedData = sorted.map(function (_a) {
-            var _b = __read(_a, 2), val = _b[1];
-            return val;
-        });
-        var recursive = function (arr, data) {
+        sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
+        sortedData = sorted.map(([, val]) => val);
+        const recursive = (arr, data) => {
             if (arr.length === 0)
                 return;
-            var mid = Math.floor((arr.length - 1) / 2);
-            var newNode = _this.add(arr[mid], data === null || data === void 0 ? void 0 : data[mid]);
+            const mid = Math.floor((arr.length - 1) / 2);
+            const newNode = this.add(arr[mid], data === null || data === void 0 ? void 0 : data[mid]);
             inserted.push(newNode);
             recursive(arr.slice(0, mid), data === null || data === void 0 ? void 0 : data.slice(0, mid));
             recursive(arr.slice(mid + 1), data === null || data === void 0 ? void 0 : data.slice(mid + 1));
         };
-        var iterative = function () {
-            var n = sorted.length;
-            var stack = [[0, n - 1]];
+        const iterative = () => {
+            const n = sorted.length;
+            const stack = [[0, n - 1]];
             while (stack.length > 0) {
-                var popped = stack.pop();
+                const popped = stack.pop();
                 if (popped) {
-                    var _a = __read(popped, 2), l = _a[0], r = _a[1];
+                    const [l, r] = popped;
                     if (l <= r) {
-                        var m = l + Math.floor((r - l) / 2);
-                        var newNode = _this.add(sortedIdsOrNodes[m], sortedData === null || sortedData === void 0 ? void 0 : sortedData[m]);
+                        const m = l + Math.floor((r - l) / 2);
+                        const newNode = this.add(sortedKeysOrNodes[m], sortedData === null || sortedData === void 0 ? void 0 : sortedData[m]);
                         inserted.push(newNode);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -229,63 +151,60 @@ var BST = (function (_super) {
             }
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            recursive(sortedIdsOrNodes, sortedData);
+            recursive(sortedKeysOrNodes, sortedData);
         }
         else {
             iterative();
         }
         return inserted;
-    };
-    BST.prototype.get = function (nodeProperty, propertyName) {
+    }
+    get(nodeProperty, propertyName = 'key') {
         var _a;
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
-    };
-    BST.prototype.lastKey = function () {
+    }
+    lastKey() {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === types_1.CP.lt)
-            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 0;
+            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
         else if (this._compare(0, 1) === types_1.CP.gt)
-            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : 0;
+            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
         else
-            return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
-    };
-    BST.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
-        var _this = this;
-        if (propertyName === void 0) { propertyName = 'id'; }
+            return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
+    }
+    getNodes(nodeProperty, propertyName = 'key', onlyOne = false) {
         if (!this.root)
             return [];
-        var result = [];
+        const result = [];
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_1 = function (cur) {
-                if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
+            const _traverse = (cur) => {
+                if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
                 if (!cur.left && !cur.right)
                     return;
-                if (propertyName === 'id') {
-                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.gt)
-                        cur.left && _traverse_1(cur.left);
-                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.lt)
-                        cur.right && _traverse_1(cur.right);
+                if (propertyName === 'key') {
+                    if (this._compare(cur.key, nodeProperty) === types_1.CP.gt)
+                        cur.left && _traverse(cur.left);
+                    if (this._compare(cur.key, nodeProperty) === types_1.CP.lt)
+                        cur.right && _traverse(cur.right);
                 }
                 else {
-                    cur.left && _traverse_1(cur.left);
-                    cur.right && _traverse_1(cur.right);
+                    cur.left && _traverse(cur.left);
+                    cur.right && _traverse(cur.right);
                 }
             };
-            _traverse_1(this.root);
+            _traverse(this.root);
         }
         else {
-            var queue = [this.root];
+            const queue = [this.root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
                     if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
-                    if (propertyName === 'id') {
-                        if (this._compare(cur.id, nodeProperty) === types_1.CP.gt)
+                    if (propertyName === 'key') {
+                        if (this._compare(cur.key, nodeProperty) === types_1.CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.id, nodeProperty) === types_1.CP.lt)
+                        if (this._compare(cur.key, nodeProperty) === types_1.CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -296,62 +215,60 @@ var BST = (function (_super) {
             }
         }
         return result;
-    };
-    BST.prototype.lesserSum = function (beginNode, propertyName) {
-        var _this = this;
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+    }
+    lesserSum(beginNode, propertyName = 'key') {
         if (typeof beginNode === 'number')
-            beginNode = this.get(beginNode, 'id');
+            beginNode = this.get(beginNode, 'key');
         if (!beginNode)
             return 0;
         if (!this.root)
             return 0;
-        var id = beginNode.id;
-        var getSumByPropertyName = function (cur) {
-            var needSum;
+        const key = beginNode.key;
+        const getSumByPropertyName = (cur) => {
+            let needSum;
             switch (propertyName) {
-                case 'id':
-                    needSum = cur.id;
+                case 'key':
+                    needSum = cur.key;
                     break;
                 default:
-                    needSum = cur.id;
+                    needSum = cur.key;
                     break;
             }
             return needSum;
         };
-        var sum = 0;
+        let sum = 0;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_2 = function (cur) {
-                var compared = _this._compare(cur.id, id);
+            const _traverse = (cur) => {
+                const compared = this._compare(cur.key, key);
                 if (compared === types_1.CP.eq) {
                     if (cur.right)
-                        sum += _this.subTreeSum(cur.right, propertyName);
+                        sum += this.subTreeSum(cur.right, propertyName);
                     return;
                 }
                 else if (compared === types_1.CP.lt) {
                     if (cur.left)
-                        sum += _this.subTreeSum(cur.left, propertyName);
+                        sum += this.subTreeSum(cur.left, propertyName);
                     sum += getSumByPropertyName(cur);
                     if (cur.right)
-                        _traverse_2(cur.right);
+                        _traverse(cur.right);
                     else
                         return;
                 }
                 else {
                     if (cur.left)
-                        _traverse_2(cur.left);
+                        _traverse(cur.left);
                     else
                         return;
                 }
             };
-            _traverse_2(this.root);
+            _traverse(this.root);
         }
         else {
-            var queue = [this.root];
+            const queue = [this.root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
-                    var compared = this._compare(cur.id, id);
+                    const compared = this._compare(cur.key, key);
                     if (compared === types_1.CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSum(cur.right, propertyName);
@@ -376,88 +293,85 @@ var BST = (function (_super) {
             }
         }
         return sum;
-    };
-    BST.prototype.allGreaterNodesAdd = function (node, delta, propertyName) {
-        var _this = this;
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+    }
+    allGreaterNodesAdd(node, delta, propertyName = 'key') {
         if (typeof node === 'number')
-            node = this.get(node, 'id');
+            node = this.get(node, 'key');
         if (!node)
             return false;
-        var id = node.id;
+        const key = node.key;
         if (!this.root)
             return false;
-        var _sumByPropertyName = function (cur) {
+        const _sumByPropertyName = (cur) => {
             switch (propertyName) {
-                case 'id':
-                    cur.id += delta;
+                case 'key':
+                    cur.key += delta;
                     break;
                 default:
-                    cur.id += delta;
+                    cur.key += delta;
                     break;
             }
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_3 = function (cur) {
-                var compared = _this._compare(cur.id, id);
+            const _traverse = (cur) => {
+                const compared = this._compare(cur.key, key);
                 if (compared === types_1.CP.gt)
                     _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && _this._compare(cur.left.id, id) === types_1.CP.gt)
-                    _traverse_3(cur.left);
-                if (cur.right && _this._compare(cur.right.id, id) === types_1.CP.gt)
-                    _traverse_3(cur.right);
+                if (cur.left && this._compare(cur.left.key, key) === types_1.CP.gt)
+                    _traverse(cur.left);
+                if (cur.right && this._compare(cur.right.key, key) === types_1.CP.gt)
+                    _traverse(cur.right);
             };
-            _traverse_3(this.root);
+            _traverse(this.root);
             return true;
         }
         else {
-            var queue = [this.root];
+            const queue = [this.root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
-                    var compared = this._compare(cur.id, id);
+                    const compared = this._compare(cur.key, key);
                     if (compared === types_1.CP.gt)
                         _sumByPropertyName(cur);
-                    if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
+                    if (cur.left && this._compare(cur.left.key, key) === types_1.CP.gt)
                         queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.id, id) === types_1.CP.gt)
+                    if (cur.right && this._compare(cur.right.key, key) === types_1.CP.gt)
                         queue.push(cur.right);
                 }
             }
             return true;
         }
-    };
-    BST.prototype.perfectlyBalance = function () {
-        var _this = this;
-        var sorted = this.DFS('in', 'node'), n = sorted.length;
+    }
+    perfectlyBalance() {
+        const sorted = this.dfs('in', 'node'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
             return false;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var buildBalanceBST_1 = function (l, r) {
+            const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
-                var m = l + Math.floor((r - l) / 2);
-                var midNode = sorted[m];
-                _this.add(midNode.id, midNode.val);
-                buildBalanceBST_1(l, m - 1);
-                buildBalanceBST_1(m + 1, r);
+                const m = l + Math.floor((r - l) / 2);
+                const midNode = sorted[m];
+                this.add(midNode.key, midNode.val);
+                buildBalanceBST(l, m - 1);
+                buildBalanceBST(m + 1, r);
             };
-            buildBalanceBST_1(0, n - 1);
+            buildBalanceBST(0, n - 1);
             return true;
         }
         else {
-            var stack = [[0, n - 1]];
+            const stack = [[0, n - 1]];
             while (stack.length > 0) {
-                var popped = stack.pop();
+                const popped = stack.pop();
                 if (popped) {
-                    var _a = __read(popped, 2), l = _a[0], r = _a[1];
+                    const [l, r] = popped;
                     if (l <= r) {
-                        var m = l + Math.floor((r - l) / 2);
-                        var midNode = sorted[m];
-                        this.add(midNode.id, midNode.val);
+                        const m = l + Math.floor((r - l) / 2);
+                        const midNode = sorted[m];
+                        this.add(midNode.key, midNode.val);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -465,27 +379,27 @@ var BST = (function (_super) {
             }
             return true;
         }
-    };
-    BST.prototype.isAVLBalanced = function () {
+    }
+    isAVLBalanced() {
         var _a, _b;
         if (!this.root)
             return true;
-        var balanced = true;
+        let balanced = true;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _height_1 = function (cur) {
+            const _height = (cur) => {
                 if (!cur)
                     return 0;
-                var leftHeight = _height_1(cur.left), rightHeight = _height_1(cur.right);
+                const leftHeight = _height(cur.left), rightHeight = _height(cur.right);
                 if (Math.abs(leftHeight - rightHeight) > 1)
                     balanced = false;
                 return Math.max(leftHeight, rightHeight) + 1;
             };
-            _height_1(this.root);
+            _height(this.root);
         }
         else {
-            var stack = [];
-            var node = this.root, last = null;
-            var depths = new Map();
+            const stack = [];
+            let node = this.root, last = null;
+            const depths = new Map();
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
@@ -496,8 +410,8 @@ var BST = (function (_super) {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            var left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            var right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            const left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            const right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
                             if (Math.abs(left - right) > 1)
                                 return false;
                             depths.set(node, 1 + Math.max(left, right));
@@ -511,17 +425,16 @@ var BST = (function (_super) {
             }
         }
         return balanced;
-    };
-    BST.prototype._compare = function (a, b) {
-        var compared = this._comparator(a, b);
+    }
+    _compare(a, b) {
+        const compared = this._comparator(a, b);
         if (compared > 0)
             return types_1.CP.gt;
         else if (compared < 0)
             return types_1.CP.lt;
         else
             return types_1.CP.eq;
-    };
-    return BST;
-}(binary_tree_1.BinaryTree));
+    }
+}
 exports.BST = BST;
 //# sourceMappingURL=bst.js.map