data-structure-typed 1.21.4 → 1.31.0

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

@@ -1,70 +1,91 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeMultiset = exports.TreeMultisetNode = void 0;
-const types_1 = require("../../types");
-const avl_tree_1 = require("./avl-tree");
-class TreeMultisetNode extends avl_tree_1.AVLTreeNode {
-    /**
-     * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
-     * of the binary tree node.
-     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value of the binary
-     * tree node. If no value is provided, it will be `undefined`.
-     * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
-     * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
-     * parameter when creating a new instance of the `BinaryTreeNode` class,
-     */
-    constructor(id, val, count = 1) {
-        super(id, val);
-        this._count = count;
+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 __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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);
     }
-    get count() {
-        return this._count;
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
     }
-    set count(v) {
-        this._count = v;
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeMultiset = exports.TreeMultisetNode = void 0;
+var types_1 = require("../../types");
+var avl_tree_1 = require("./avl-tree");
+var TreeMultisetNode = (function (_super) {
+    __extends(TreeMultisetNode, _super);
+    function TreeMultisetNode(id, val, count) {
+        if (count === void 0) { count = 1; }
+        var _this = _super.call(this, id, val) || this;
+        _this._count = count;
+        return _this;
     }
-}
+    Object.defineProperty(TreeMultisetNode.prototype, "count", {
+        get: function () {
+            return this._count;
+        },
+        set: function (v) {
+            this._count = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TreeMultisetNode;
+}(avl_tree_1.AVLTreeNode));
 exports.TreeMultisetNode = TreeMultisetNode;
-/**
- * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
- */
-class TreeMultiset extends avl_tree_1.AVLTree {
-    /**
-     * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
-     * merge duplicated values.
-     * @param {TreeMultisetOptions} [options] - An optional object that contains additional configuration options for the
-     * TreeMultiset.
-     */
-    constructor(options) {
-        super(Object.assign({}, options));
-        this._count = 0;
-    }
-    get count() {
-        return this._count;
+var TreeMultiset = (function (_super) {
+    __extends(TreeMultiset, _super);
+    function TreeMultiset(options) {
+        var _this = _super.call(this, __assign({}, options)) || this;
+        _this._count = 0;
+        return _this;
     }
-    /**
-     * The function creates a new BSTNode with the given id, value, and count.
-     * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
-     * distinguish one node from another in the tree.
-     * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
-     * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
-     * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
-     * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
-     */
-    createNode(id, val, count) {
+    Object.defineProperty(TreeMultiset.prototype, "count", {
+        get: function () {
+            return this._count;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TreeMultiset.prototype.createNode = function (id, val, count) {
         return new TreeMultisetNode(id, val, count);
-    }
-    /**
-     * The function swaps the location of two nodes in a tree data structure.
-     * @param {N} srcNode - The source node that we want to swap with the destination node.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
-     * be swapped with.
-     * @returns the `destNode` after swapping its values with the `srcNode`.
-     */
-    swapLocation(srcNode, destNode) {
-        const { id, val, count, height } = destNode;
-        const tempNode = this.createNode(id, val, count);
+    };
+    TreeMultiset.prototype.swapLocation = function (srcNode, destNode) {
+        var id = destNode.id, val = destNode.val, count = destNode.count, height = destNode.height;
+        var tempNode = this.createNode(id, val, count);
         if (tempNode) {
             tempNode.height = height;
             destNode.id = srcNode.id;
@@ -77,20 +98,10 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             srcNode.height = tempNode.height;
         }
         return destNode;
-    }
-    /**
-     * The `add` function adds a new node to a binary search tree, maintaining the tree's properties and balancing if
-     * necessary.
-     * @param {BinaryTreeNodeId | N} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId` or a `N` (which
-     * represents a `BinaryTreeNode`).
-     * @param [val] - The `val` parameter represents the value to be added to the binary tree node.
-     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
-     * value should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
-     * @returns The method `add` returns either the inserted node (`N`), `null`, or `undefined`.
-     */
-    add(idOrNode, val, count) {
+    };
+    TreeMultiset.prototype.add = function (idOrNode, val, count) {
         count = count !== null && count !== void 0 ? count : 1;
-        let inserted = undefined, newNode;
+        var inserted = undefined, newNode;
         if (idOrNode instanceof TreeMultisetNode) {
             newNode = this.createNode(idOrNode.id, idOrNode.val, idOrNode.count);
         }
@@ -107,8 +118,8 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             inserted = this.root;
         }
         else {
-            let cur = this.root;
-            let traversing = true;
+            var cur = this.root;
+            var traversing = true;
             while (traversing) {
                 if (cur) {
                     if (newNode) {
@@ -120,9 +131,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                             inserted = cur;
                         }
                         else if (this._compare(cur.id, newNode.id) === types_1.CP.gt) {
-                            // Traverse left of the node
                             if (cur.left === undefined) {
-                                //Add to the left of the current node
                                 cur.left = newNode;
                                 this._setSize(this.size + 1);
                                 this._setCount(this.count + newNode.count);
@@ -130,30 +139,25 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                                 inserted = cur.left;
                             }
                             else {
-                                //Traverse the left of the current node
                                 if (cur.left)
                                     cur = cur.left;
                             }
                         }
                         else if (this._compare(cur.id, newNode.id) === types_1.CP.lt) {
-                            // Traverse right of the node
                             if (cur.right === undefined) {
-                                //Add to the right of the current node
                                 cur.right = newNode;
                                 this._setSize(this.size + 1);
                                 this._setCount(this.count + newNode.count);
                                 traversing = false;
-                                inserted = (cur.right);
+                                inserted = cur.right;
                             }
                             else {
-                                //Traverse the left of the current node
                                 if (cur.right)
                                     cur = cur.right;
                             }
                         }
                     }
                     else {
-                        // TODO may need to support null inserted
                     }
                 }
                 else {
@@ -162,19 +166,10 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             }
         }
         if (inserted)
-            this.balancePath(inserted);
+            this._balancePath(inserted);
         return inserted;
-    }
-    /**
-     * The function adds a new node to a binary tree if there is an available slot on the left or right side of the parent
-     * node.
-     * @param {N | null} newNode - The `newNode` parameter represents the node that needs to be added to the tree. It can
-     * be either a node object (`N`) or `null`.
-     * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
-     * child.
-     * @returns The method returns either the `parent.left`, `parent.right`, or `undefined`.
-     */
-    _addTo(newNode, parent) {
+    };
+    TreeMultiset.prototype._addTo = function (newNode, parent) {
         if (parent) {
             if (parent.left === undefined) {
                 parent.left = newNode;
@@ -199,72 +194,51 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         else {
             return;
         }
-    }
-    /**
-     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes.
-     * @param {BinaryTreeNodeId[] | N[]} idsOrNodes - An array of BinaryTreeNodeId objects or N objects. These objects
-     * represent the IDs or nodes of the binary tree where the values will be added.
-     * @param {N['val'][]} [data] - Optional array of values to be associated with each node being added. If provided, the
-     * length of the `data` array should be equal to the length of the `idsOrNodes` array.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
-     */
-    addMany(idsOrNodes, data) {
-        var _a;
-        // TODO not sure addMany not be run multi times
-        const inserted = [];
-        const map = new Map();
-        for (const idOrNode of idsOrNodes)
-            map.set(idOrNode, ((_a = map.get(idOrNode)) !== null && _a !== void 0 ? _a : 0) + 1);
-        for (let i = 0; i < idsOrNodes.length; i++) {
-            const idOrNode = idsOrNodes[i];
-            if (map.has(idOrNode)) {
-                if (idOrNode instanceof TreeMultisetNode) {
-                    inserted.push(this.add(idOrNode.id, idOrNode.val, idOrNode.count));
-                    continue;
-                }
-                if (idOrNode === null) {
-                    inserted.push(this.add(NaN, null, 0));
-                    continue;
-                }
-                const val = data === null || data === void 0 ? void 0 : data[i], count = map.get(idOrNode);
-                inserted.push(this.add(idOrNode, val, count));
-                map.delete(idOrNode);
+    };
+    TreeMultiset.prototype.addMany = function (idsOrNodes, data) {
+        var inserted = [];
+        for (var i = 0; i < idsOrNodes.length; i++) {
+            var idOrNode = idsOrNodes[i];
+            if (idOrNode instanceof TreeMultisetNode) {
+                inserted.push(this.add(idOrNode.id, idOrNode.val, idOrNode.count));
+                continue;
             }
+            if (idOrNode === null) {
+                inserted.push(this.add(NaN, null, 0));
+                continue;
+            }
+            inserted.push(this.add(idOrNode, data === null || data === void 0 ? void 0 : data[i], 1));
         }
         return inserted;
-    }
-    /**
-     * The `perfectlyBalance` function takes a binary tree, performs a depth-first search to sort the nodes, and then
-     * constructs a balanced binary search tree using either a recursive or iterative approach.
-     * @returns The function `perfectlyBalance()` returns a boolean value.
-     */
-    perfectlyBalance() {
-        const sorted = this.DFS('in', 'node'), n = sorted.length;
+    };
+    TreeMultiset.prototype.perfectlyBalance = function () {
+        var _this = this;
+        var sorted = this.DFS('in', 'node'), n = sorted.length;
         if (sorted.length < 1)
             return false;
         this.clear();
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const buildBalanceBST = (l, r) => {
+            var buildBalanceBST_1 = function (l, r) {
                 if (l > r)
                     return;
-                const m = l + Math.floor((r - l) / 2);
-                const midNode = sorted[m];
-                this.add(midNode.id, midNode.val, midNode.count);
-                buildBalanceBST(l, m - 1);
-                buildBalanceBST(m + 1, r);
+                var m = l + Math.floor((r - l) / 2);
+                var midNode = sorted[m];
+                _this.add(midNode.id, midNode.val, midNode.count);
+                buildBalanceBST_1(l, m - 1);
+                buildBalanceBST_1(m + 1, r);
             };
-            buildBalanceBST(0, n - 1);
+            buildBalanceBST_1(0, n - 1);
             return true;
         }
         else {
-            const stack = [[0, n - 1]];
+            var stack = [[0, n - 1]];
             while (stack.length > 0) {
-                const popped = stack.pop();
+                var popped = stack.pop();
                 if (popped) {
-                    const [l, r] = popped;
+                    var _a = __read(popped, 2), l = _a[0], r = _a[1];
                     if (l <= r) {
-                        const m = l + Math.floor((r - l) / 2);
-                        const midNode = sorted[m];
+                        var m = l + Math.floor((r - l) / 2);
+                        var midNode = sorted[m];
                         this.add(midNode.id, midNode.val, midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -273,25 +247,16 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             }
             return true;
         }
-    }
-    /**
-     * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
-     * node that needs to be balanced.
-     * @param {N | BinaryTreeNodeId | null} nodeOrId - The `nodeOrId` parameter can be one of the following:
-     * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
-     * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
-     * not be taken into account when removing it. If `ignoreCount` is set to `false
-     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
-     */
-    remove(nodeOrId, ignoreCount) {
-        const bstDeletedResult = [];
+    };
+    TreeMultiset.prototype.remove = function (nodeOrId, ignoreCount) {
+        var bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = this.get(nodeOrId);
+        var curr = this.get(nodeOrId);
         if (!curr)
             return bstDeletedResult;
-        const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
-        let needBalanced = null, orgCurrent = curr;
+        var parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        var needBalanced = null, orgCurrent = curr;
         if (curr.count > 1 && !ignoreCount) {
             curr.count--;
             this._setCount(this.count - 1);
@@ -303,7 +268,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                         this._setRoot(curr.right);
                 }
                 else {
-                    const { familyPosition: fp } = curr;
+                    var fp = curr.familyPosition;
                     if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
                         parent.left = curr.right;
                     }
@@ -314,9 +279,9 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                 }
             }
             else {
-                const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
+                var leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
                 if (leftSubTreeRightMost) {
-                    const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+                    var parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
                     orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
                         if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
@@ -330,40 +295,32 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                 }
             }
             this._setSize(this.size - 1);
-            // TODO How to handle when the count of target node is lesser than current node's count
             this._setCount(this.count - orgCurrent.count);
         }
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
+        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
         if (needBalanced) {
-            this.balancePath(needBalanced);
+            this._balancePath(needBalanced);
         }
         return bstDeletedResult;
-    }
-    /**
-     * The function `getSubTreeCount` calculates the number of nodes and the sum of their counts in a subtree, using either
-     * recursive or iterative traversal.
-     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
-     * binary tree.
-     * @returns The function `getSubTreeCount` returns an array `[number, number]`.
-     */
-    getSubTreeCount(subTreeRoot) {
-        const res = [0, 0];
+    };
+    TreeMultiset.prototype.getSubTreeCount = function (subTreeRoot) {
+        var res = [0, 0];
         if (!subTreeRoot)
             return res;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
+            var _traverse_1 = function (cur) {
                 res[0]++;
                 res[1] += cur.count;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                cur.left && _traverse_1(cur.left);
+                cur.right && _traverse_1(cur.right);
             };
-            _traverse(subTreeRoot);
+            _traverse_1(subTreeRoot);
             return res;
         }
         else {
-            const stack = [subTreeRoot];
+            var stack = [subTreeRoot];
             while (stack.length > 0) {
-                const cur = stack.pop();
+                var cur = stack.pop();
                 res[0]++;
                 res[1] += cur.count;
                 cur.right && stack.push(cur.right);
@@ -371,94 +328,67 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             }
             return res;
         }
-    }
-    /**
-     * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
-     * recursively or iteratively.
-     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree) or
-     * `null` if the subtree is empty.
-     * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
-     */
-    subTreeSumCount(subTreeRoot) {
+    };
+    TreeMultiset.prototype.subTreeSumCount = function (subTreeRoot) {
         if (typeof subTreeRoot === 'number')
             subTreeRoot = this.get(subTreeRoot, 'id');
         if (!subTreeRoot)
             return 0;
-        let sum = 0;
+        var sum = 0;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
+            var _traverse_2 = function (cur) {
                 sum += cur.count;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                cur.left && _traverse_2(cur.left);
+                cur.right && _traverse_2(cur.right);
             };
-            _traverse(subTreeRoot);
+            _traverse_2(subTreeRoot);
         }
         else {
-            const stack = [subTreeRoot];
+            var stack = [subTreeRoot];
             while (stack.length > 0) {
-                const cur = stack.pop();
+                var cur = stack.pop();
                 sum += cur.count;
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
         }
         return sum;
-    }
-    /**
-     * The function `subTreeAddCount` recursively or iteratively traverses a binary tree and adds a given delta value to
-     * the `count` property of each node.
-     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree), a
-     * `BinaryTreeNode` object, or `null` if the subtree is empty.
-     * @param {number} delta - The delta parameter is a number that represents the amount by which the count of each node
-     * in the subtree should be increased or decreased.
-     * @returns a boolean value.
-     */
-    subTreeAddCount(subTreeRoot, delta) {
+    };
+    TreeMultiset.prototype.subTreeAddCount = function (subTreeRoot, delta) {
+        var _this = this;
         if (typeof subTreeRoot === 'number')
             subTreeRoot = this.get(subTreeRoot, 'id');
         if (!subTreeRoot)
             return false;
-        const _addByProperty = (cur) => {
+        var _addByProperty = function (cur) {
             cur.count += delta;
-            this._setCount(this.count + delta);
+            _this._setCount(_this.count + delta);
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
+            var _traverse_3 = function (cur) {
                 _addByProperty(cur);
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                cur.left && _traverse_3(cur.left);
+                cur.right && _traverse_3(cur.right);
             };
-            _traverse(subTreeRoot);
+            _traverse_3(subTreeRoot);
         }
         else {
-            const stack = [subTreeRoot];
+            var stack = [subTreeRoot];
             while (stack.length > 0) {
-                const cur = stack.pop();
+                var cur = stack.pop();
                 _addByProperty(cur);
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
         }
         return true;
-    }
-    /**
-     * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
-     * using a queue.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * `N`. It represents the property of the nodes that you want to search for.
-     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
-     * return only one node that matches the `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne` is set
-     * to `true`, the function will return only one node. If `onlyOne`
-     * @returns an array of nodes that match the given nodeProperty.
-     */
-    getNodesByCount(nodeProperty, onlyOne) {
+    };
+    TreeMultiset.prototype.getNodesByCount = function (nodeProperty, onlyOne) {
         if (!this.root)
             return [];
-        const result = [];
+        var result = [];
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
+            var _traverse_4 = function (cur) {
                 if (cur.count === nodeProperty) {
                     result.push(cur);
                     if (onlyOne)
@@ -466,15 +396,15 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                 }
                 if (!cur.left && !cur.right)
                     return;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                cur.left && _traverse_4(cur.left);
+                cur.right && _traverse_4(cur.right);
             };
-            _traverse(this.root);
+            _traverse_4(this.root);
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
                     if (cur.count === nodeProperty) {
                         result.push(cur);
@@ -487,123 +417,78 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             }
         }
         return result;
-    }
-    /**
-     * The BFSCount function returns an array of counts from a breadth-first search of nodes.
-     * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
-     * BFS traversal.
-     */
-    BFSCount() {
-        const nodes = super.BFS('node');
-        return nodes.map(node => node.count);
-    }
-    /**
-     * The function "listLevelsCount" takes a node and returns an array of arrays, where each inner array contains the
-     * count property of each node at that level.
-     * @param {N | null} node - The parameter `node` is of type `N | null`. This means that it can either be an instance of
-     * the class `N` or `null`.
-     * @returns a 2D array of numbers. Each inner array represents a level in the binary tree, and each number in the inner
-     * array represents the count property of a node in that level.
-     */
-    listLevelsCount(node) {
-        const levels = super.listLevels(node, 'node');
-        return levels.map(level => level.map(node => node.count));
-    }
-    /**
-     * The `morrisCount` function returns an array of counts for each node in a binary tree, based on a specified traversal
-     * pattern.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The `pattern` parameter is an optional parameter that specifies the
-     * traversal pattern for the Morris traversal algorithm. It can have one of three values: 'in', 'pre', or 'post'.
-     * @returns The function `morrisCount` returns an array of numbers.
-     */
-    morrisCount(pattern) {
+    };
+    TreeMultiset.prototype.BFSCount = function () {
+        var nodes = _super.prototype.BFS.call(this, 'node');
+        return nodes.map(function (node) { return node.count; });
+    };
+    TreeMultiset.prototype.listLevelsCount = function (node) {
+        var levels = _super.prototype.listLevels.call(this, node, 'node');
+        return levels.map(function (level) { return level.map(function (node) { return node.count; }); });
+    };
+    TreeMultiset.prototype.morrisCount = function (pattern) {
         pattern = pattern || 'in';
-        const nodes = super.morris(pattern, 'node');
-        return nodes.map(node => node.count);
-    }
-    /**
-     * The function DFSIterativeCount performs a depth-first search iteratively and returns an array of count values for
-     * each node.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The "pattern" parameter is a string that specifies the traversal order
-     * for the Depth-First Search (DFS) algorithm. It can have one of three values: 'in', 'pre', or 'post'.
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
-     * specifies whether to return the nodes or the property names during the depth-first search traversal. If it is set to
-     * `'node'`, the function will return the nodes. If it is set to `'property'`, the function will return the property
-     * @returns The DFSIterativeCount method returns an array of numbers.
-     */
-    DFSIterativeCount(pattern, nodeOrPropertyName) {
+        var nodes = _super.prototype.morris.call(this, pattern, 'node');
+        return nodes.map(function (node) { return node.count; });
+    };
+    TreeMultiset.prototype.DFSIterativeCount = function (pattern) {
         pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
-        const nodes = super.DFSIterative(pattern, 'node');
-        return nodes.map(node => node.count);
-    }
-    /**
-     * The DFSCount function returns an array of counts for each node in a depth-first search traversal.
-     * @param {DFSOrderPattern} [pattern] - The `pattern` parameter is an optional parameter that specifies the order in
-     * which the Depth-First Search (DFS) algorithm should traverse the nodes. It can have one of the following values:
-     * @param [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is used to specify whether you want to retrieve the
-     * nodes themselves or a specific property of the nodes. If you pass `'count'` as the value for `nodeOrPropertyName`,
-     * the function will return an array of the `count` property of each node.
-     * @returns The DFSCount method returns an array of numbers representing the count property of each node in the DFS
-     * traversal.
-     */
-    DFSCount(pattern, nodeOrPropertyName) {
+        var nodes = _super.prototype.DFSIterative.call(this, pattern, 'node');
+        return nodes.map(function (node) { return node.count; });
+    };
+    TreeMultiset.prototype.DFSCount = function (pattern) {
         pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
-        const nodes = super.DFS(pattern, 'node');
-        return nodes.map(node => node.count);
-    }
-    /**
-     * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
-     * value than a given node.
-     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
-     * @returns the sum of the counts of nodes in the binary tree that have a lesser value than the given beginNode.
-     */
-    lesserSumCount(beginNode) {
+        var nodes = _super.prototype.DFS.call(this, pattern, 'node');
+        return nodes.map(function (node) { return node.count; });
+    };
+    TreeMultiset.prototype.lesserSumCount = function (beginNode) {
+        var _this = this;
         if (typeof beginNode === 'number')
             beginNode = this.get(beginNode, 'id');
         if (!beginNode)
             return 0;
         if (!this.root)
             return 0;
-        const id = beginNode.id;
-        let sum = 0;
+        var id = beginNode.id;
+        var sum = 0;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.id, id);
+            var _traverse_5 = function (cur) {
+                var compared = _this._compare(cur.id, id);
                 if (compared === types_1.CP.eq) {
                     if (cur.right)
-                        sum += this.subTreeSumCount(cur.right);
+                        sum += _this.subTreeSumCount(cur.right);
                     return;
                 }
                 else if (compared === types_1.CP.lt) {
                     if (cur.left)
-                        sum += this.subTreeSumCount(cur.left);
+                        sum += _this.subTreeSumCount(cur.left);
                     sum += cur.count;
                     if (cur.right)
-                        _traverse(cur.right);
+                        _traverse_5(cur.right);
                     else
                         return;
                 }
                 else {
                     if (cur.left)
-                        _traverse(cur.left);
+                        _traverse_5(cur.left);
                     else
                         return;
                 }
             };
-            _traverse(this.root);
+            _traverse_5(this.root);
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, id);
+                    var compared = this._compare(cur.id, id);
                     if (compared === types_1.CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSumCount(cur.right);
                         return sum;
                     }
-                    else if (compared === types_1.CP.lt) { // todo maybe a bug
+                    else if (compared === types_1.CP.lt) {
                         if (cur.left)
                             sum += this.subTreeSumCount(cur.left);
                         sum += cur.count;
@@ -622,44 +507,37 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             }
         }
         return sum;
-    }
-    /**
-     * The function `allGreaterNodesAddCount` updates the count property of all nodes in a binary tree that have an ID
-     * greater than a given ID by a specified delta value.
-     * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be one of the following:
-     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the `count` property
-     * of each node should be increased.
-     * @returns a boolean value.
-     */
-    allGreaterNodesAddCount(node, delta) {
+    };
+    TreeMultiset.prototype.allGreaterNodesAddCount = function (node, delta) {
+        var _this = this;
         if (typeof node === 'number')
             node = this.get(node, 'id');
         if (!node)
             return false;
-        const id = node.id;
+        var id = node.id;
         if (!this.root)
             return false;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.id, id);
+            var _traverse_6 = function (cur) {
+                var compared = _this._compare(cur.id, id);
                 if (compared === types_1.CP.gt)
                     cur.count += delta;
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
-                    _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.id, id) === types_1.CP.gt)
-                    _traverse(cur.right);
+                if (cur.left && _this._compare(cur.left.id, id) === types_1.CP.gt)
+                    _traverse_6(cur.left);
+                if (cur.right && _this._compare(cur.right.id, id) === types_1.CP.gt)
+                    _traverse_6(cur.right);
             };
-            _traverse(this.root);
+            _traverse_6(this.root);
             return true;
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, id);
+                    var compared = this._compare(cur.id, id);
                     if (compared === types_1.CP.gt)
                         cur.count += delta;
                     if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
@@ -670,20 +548,15 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             }
             return true;
         }
-    }
-    /**
-     * The clear() function clears the data and sets the count to 0.
-     */
-    clear() {
-        super.clear();
+    };
+    TreeMultiset.prototype.clear = function () {
+        _super.prototype.clear.call(this);
         this._setCount(0);
-    }
-    /**
-     * The function "_setCount" is used to set the value of the "_count" property.
-     * @param {number} v - number
-     */
-    _setCount(v) {
+    };
+    TreeMultiset.prototype._setCount = function (v) {
         this._count = v;
-    }
-}
+    };
+    return TreeMultiset;
+}(avl_tree_1.AVLTree));
 exports.TreeMultiset = TreeMultiset;
+//# sourceMappingURL=tree-multiset.js.map