data-structure-typed 1.19.2 → 1.19.4

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

@@ -1,47 +1,9 @@
 "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 __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 __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.");
-};
 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 = /** @class */ (function (_super) {
-    __extends(TreeMultisetNode, _super);
+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
@@ -52,49 +14,36 @@ var TreeMultisetNode = /** @class */ (function (_super) {
      * 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,
      */
-    function TreeMultisetNode(id, val, count) {
-        if (count === void 0) { count = 1; }
-        var _this = _super.call(this, id, val) || this;
-        _this._count = 1;
-        _this._count = count;
-        return _this;
+    constructor(id, val, count = 1) {
+        super(id, val);
+        this._count = 1;
+        this._count = count;
+    }
+    get count() {
+        return this._count;
     }
-    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));
+    set count(v) {
+        this._count = v;
+    }
+}
 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.
  */
-var TreeMultiset = /** @class */ (function (_super) {
-    __extends(TreeMultiset, _super);
+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.
      */
-    function TreeMultiset(options) {
-        var _this = _super.call(this, __assign(__assign({}, options), { isMergeDuplicatedVal: true })) || this;
-        _this._count = 0;
-        return _this;
+    constructor(options) {
+        super(Object.assign(Object.assign({}, options), { isMergeDuplicatedVal: true }));
+        this._count = 0;
+    }
+    get count() {
+        return this._count;
     }
-    Object.defineProperty(TreeMultiset.prototype, "count", {
-        get: function () {
-            return this._count;
-        },
-        enumerable: false,
-        configurable: true
-    });
     /**
      * 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
@@ -104,9 +53,9 @@ var TreeMultiset = /** @class */ (function (_super) {
      * 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).
      */
-    TreeMultiset.prototype.createNode = function (id, val, count) {
+    createNode(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.
@@ -114,9 +63,9 @@ var TreeMultiset = /** @class */ (function (_super) {
      * be swapped with.
      * @returns the `destNode` after swapping its values with the `srcNode`.
      */
-    TreeMultiset.prototype.swapLocation = function (srcNode, destNode) {
-        var val = destNode.val, count = destNode.count, height = destNode.height, id = destNode.id;
-        var tempNode = this.createNode(id, val, count);
+    swapLocation(srcNode, destNode) {
+        const { val, count, height, id } = destNode;
+        const tempNode = this.createNode(id, val, count);
         if (tempNode) {
             tempNode.height = height;
             if (tempNode instanceof TreeMultisetNode) {
@@ -131,7 +80,7 @@ var TreeMultiset = /** @class */ (function (_super) {
             }
         }
         return destNode;
-    };
+    }
     /**
      * The `add` function adds a new node to a binary tree, updating the size and count properties accordingly, and
      * balancing the tree if necessary.
@@ -143,10 +92,10 @@ var TreeMultiset = /** @class */ (function (_super) {
      * with the given `id` should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
      * @returns The `add` method returns the inserted node (`N`), `null`, or `undefined`.
      */
-    TreeMultiset.prototype.add = function (id, val, count) {
+    add(id, val, count) {
         count = count !== null && count !== void 0 ? count : 1;
-        var inserted = null;
-        var newNode = this.createNode(id, val, count);
+        let inserted = null;
+        const newNode = this.createNode(id, val, count);
         if (this.root === null) {
             this._setRoot(newNode);
             this._setSize(this.size + 1);
@@ -154,8 +103,8 @@ var TreeMultiset = /** @class */ (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, id) === types_1.CP.eq) {
@@ -215,7 +164,7 @@ var TreeMultiset = /** @class */ (function (_super) {
         if (inserted)
             this.balancePath(inserted);
         return inserted;
-    };
+    }
     /**
      * The function adds a new node to a binary tree as the left or right child of a given parent node.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
@@ -225,7 +174,7 @@ var TreeMultiset = /** @class */ (function (_super) {
      * @returns either the left or right child node that was added to the parent node. It can also return `null` or
      * `undefined` in certain cases.
      */
-    TreeMultiset.prototype.addTo = function (newNode, parent) {
+    addTo(newNode, parent) {
         var _a, _b;
         if (parent) {
             if (parent.left === undefined) {
@@ -257,7 +206,7 @@ var TreeMultiset = /** @class */ (function (_super) {
         else {
             return;
         }
-    };
+    }
     /**
      * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
@@ -265,83 +214,61 @@ var TreeMultiset = /** @class */ (function (_super) {
      * array of `N` objects.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    TreeMultiset.prototype.addMany = function (data) {
-        var e_1, _a, e_2, _b;
-        var _c;
+    addMany(data) {
+        var _a;
         // TODO not sure addMany not be run multi times
-        var inserted = [];
-        var map = new Map();
+        const inserted = [];
+        const map = new Map();
         if (this.isMergeDuplicatedVal) {
-            try {
-                for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
-                    var nodeOrId = data_1_1.value;
-                    map.set(nodeOrId, ((_c = map.get(nodeOrId)) !== null && _c !== void 0 ? _c : 0) + 1);
-                }
+            for (const nodeOrId of data)
+                map.set(nodeOrId, ((_a = map.get(nodeOrId)) !== null && _a !== void 0 ? _a : 0) + 1);
+        }
+        for (const nodeOrId of data) {
+            if (nodeOrId instanceof TreeMultisetNode) {
+                inserted.push(this.add(nodeOrId.id, nodeOrId.val, nodeOrId.count));
+                continue;
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
-                }
-                finally { if (e_1) throw e_1.error; }
+            if (nodeOrId === null) {
+                inserted.push(this.add(NaN, null, 0));
+                continue;
             }
-        }
-        try {
-            for (var data_2 = __values(data), data_2_1 = data_2.next(); !data_2_1.done; data_2_1 = data_2.next()) {
-                var nodeOrId = data_2_1.value;
-                if (nodeOrId instanceof TreeMultisetNode) {
-                    inserted.push(this.add(nodeOrId.id, nodeOrId.val, nodeOrId.count));
-                    continue;
-                }
-                if (nodeOrId === null) {
-                    inserted.push(this.add(NaN, null, 0));
-                    continue;
-                }
-                // TODO will this cause an issue?
-                var count = this.isMergeDuplicatedVal ? map.get(nodeOrId) : 1;
-                var newId = void 0;
-                if (typeof nodeOrId === 'number') {
-                    newId = this.autoIncrementId ? this.maxId + 1 : nodeOrId;
+            // TODO will this cause an issue?
+            const count = this.isMergeDuplicatedVal ? map.get(nodeOrId) : 1;
+            let newId;
+            if (typeof nodeOrId === 'number') {
+                newId = this.autoIncrementId ? this.maxId + 1 : nodeOrId;
+            }
+            else if (nodeOrId instanceof Object) {
+                if (this.autoIncrementId) {
+                    newId = this.maxId + 1;
                 }
-                else if (nodeOrId instanceof Object) {
-                    if (this.autoIncrementId) {
-                        newId = this.maxId + 1;
+                else {
+                    if (Object.keys(nodeOrId).includes('id')) {
+                        newId = nodeOrId.id;
                     }
                     else {
-                        if (Object.keys(nodeOrId).includes('id')) {
-                            newId = nodeOrId.id;
-                        }
-                        else {
-                            console.warn(nodeOrId, 'Object value must has an id property when the autoIncrementId is false');
-                            continue;
-                        }
-                    }
-                }
-                else {
-                    console.warn(nodeOrId, " is not added");
-                    continue;
-                }
-                if (this.isMergeDuplicatedVal) {
-                    if (map.has(nodeOrId)) {
-                        inserted.push(this.add(newId, nodeOrId, count));
-                        map.delete(nodeOrId);
+                        console.warn(nodeOrId, 'Object value must has an id property when the autoIncrementId is false');
+                        continue;
                     }
                 }
-                else {
-                    inserted.push(this.add(newId, nodeOrId, 1));
+            }
+            else {
+                console.warn(nodeOrId, ` is not added`);
+                continue;
+            }
+            if (this.isMergeDuplicatedVal) {
+                if (map.has(nodeOrId)) {
+                    inserted.push(this.add(newId, nodeOrId, count));
+                    map.delete(nodeOrId);
                 }
-                this._setMaxId(newId);
             }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (data_2_1 && !data_2_1.done && (_b = data_2.return)) _b.call(data_2);
+            else {
+                inserted.push(this.add(newId, nodeOrId, 1));
             }
-            finally { if (e_2) throw e_2.error; }
+            this._setMaxId(newId);
         }
         return inserted;
-    };
+    }
     /**
      * 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.
@@ -351,15 +278,15 @@ var TreeMultiset = /** @class */ (function (_super) {
      * 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.
      */
-    TreeMultiset.prototype.remove = function (nodeOrId, ignoreCount) {
-        var bstDeletedResult = [];
+    remove(nodeOrId, ignoreCount) {
+        const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        var curr = (typeof nodeOrId === 'number') ? this.get(nodeOrId) : nodeOrId;
+        const curr = (typeof nodeOrId === 'number') ? this.get(nodeOrId) : nodeOrId;
         if (!curr)
             return bstDeletedResult;
-        var parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
-        var needBalanced = null, orgCurrent = curr;
+        const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        let needBalanced = null, orgCurrent = curr;
         if (curr.count > 1 && !ignoreCount) {
             curr.count--;
             this._setCount(this.count - 1);
@@ -371,7 +298,7 @@ var TreeMultiset = /** @class */ (function (_super) {
                         this._setRoot(curr.right);
                 }
                 else {
-                    var fp = curr.familyPosition;
+                    const { familyPosition: fp } = curr;
                     if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
                         parent.left = curr.right;
                     }
@@ -382,9 +309,9 @@ var TreeMultiset = /** @class */ (function (_super) {
                 }
             }
             else {
-                var leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
+                const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
                 if (leftSubTreeRightMost) {
-                    var parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+                    const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
                     orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
                         if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
@@ -398,12 +325,12 @@ var TreeMultiset = /** @class */ (function (_super) {
             this._setSize(this.size - 1);
             this._setCount(this.count - orgCurrent.count);
         }
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
+        bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
         if (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.
@@ -411,24 +338,24 @@ var TreeMultiset = /** @class */ (function (_super) {
      * binary tree.
      * @returns The function `getSubTreeCount` returns an array `[number, number]`.
      */
-    TreeMultiset.prototype.getSubTreeCount = function (subTreeRoot) {
-        var res = [0, 0];
+    getSubTreeCount(subTreeRoot) {
+        const res = [0, 0];
         if (!subTreeRoot)
             return res;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_1 = function (cur) {
+            const _traverse = (cur) => {
                 res[0]++;
                 res[1] += cur.count;
-                cur.left && _traverse_1(cur.left);
-                cur.right && _traverse_1(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_1(subTreeRoot);
+            _traverse(subTreeRoot);
             return res;
         }
         else {
-            var stack = [subTreeRoot];
+            const stack = [subTreeRoot];
             while (stack.length > 0) {
-                var cur = stack.pop();
+                const cur = stack.pop();
                 res[0]++;
                 res[1] += cur.count;
                 cur.right && stack.push(cur.right);
@@ -436,7 +363,7 @@ var TreeMultiset = /** @class */ (function (_super) {
             }
             return res;
         }
-    };
+    }
     /**
      * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
      * recursively or iteratively.
@@ -445,31 +372,31 @@ var TreeMultiset = /** @class */ (function (_super) {
      * `null` if the subtree is empty.
      * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
      */
-    TreeMultiset.prototype.subTreeSumCount = function (subTreeRoot) {
+    subTreeSumCount(subTreeRoot) {
         if (typeof subTreeRoot === 'number')
             subTreeRoot = this.get(subTreeRoot, 'id');
         if (!subTreeRoot)
             return 0;
-        var sum = 0;
+        let sum = 0;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_2 = function (cur) {
+            const _traverse = (cur) => {
                 sum += cur.count;
-                cur.left && _traverse_2(cur.left);
-                cur.right && _traverse_2(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_2(subTreeRoot);
+            _traverse(subTreeRoot);
         }
         else {
-            var stack = [subTreeRoot];
+            const stack = [subTreeRoot];
             while (stack.length > 0) {
-                var cur = stack.pop();
+                const 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.
@@ -480,35 +407,34 @@ var TreeMultiset = /** @class */ (function (_super) {
      * in the subtree should be increased or decreased.
      * @returns a boolean value.
      */
-    TreeMultiset.prototype.subTreeAddCount = function (subTreeRoot, delta) {
-        var _this = this;
+    subTreeAddCount(subTreeRoot, delta) {
         if (typeof subTreeRoot === 'number')
             subTreeRoot = this.get(subTreeRoot, 'id');
         if (!subTreeRoot)
             return false;
-        var _addByProperty = function (cur) {
+        const _addByProperty = (cur) => {
             cur.count += delta;
-            _this._setCount(_this.count + delta);
+            this._setCount(this.count + delta);
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_3 = function (cur) {
+            const _traverse = (cur) => {
                 _addByProperty(cur);
-                cur.left && _traverse_3(cur.left);
-                cur.right && _traverse_3(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_3(subTreeRoot);
+            _traverse(subTreeRoot);
         }
         else {
-            var stack = [subTreeRoot];
+            const stack = [subTreeRoot];
             while (stack.length > 0) {
-                var cur = stack.pop();
+                const 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.
@@ -519,12 +445,12 @@ var TreeMultiset = /** @class */ (function (_super) {
      * to `true`, the function will return only one node. If `onlyOne`
      * @returns an array of nodes that match the given nodeProperty.
      */
-    TreeMultiset.prototype.getNodesByCount = function (nodeProperty, onlyOne) {
+    getNodesByCount(nodeProperty, onlyOne) {
         if (!this.root)
             return [];
-        var result = [];
+        const result = [];
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_4 = function (cur) {
+            const _traverse = (cur) => {
                 if (cur.count === nodeProperty) {
                     result.push(cur);
                     if (onlyOne)
@@ -532,15 +458,15 @@ var TreeMultiset = /** @class */ (function (_super) {
                 }
                 if (!cur.left && !cur.right)
                     return;
-                cur.left && _traverse_4(cur.left);
-                cur.right && _traverse_4(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_4(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 (cur.count === nodeProperty) {
                         result.push(cur);
@@ -553,16 +479,16 @@ var TreeMultiset = /** @class */ (function (_super) {
             }
         }
         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.
      */
-    TreeMultiset.prototype.BFSCount = function () {
-        var nodes = _super.prototype.BFS.call(this, 'node');
-        return nodes.map(function (node) { return node.count; });
-    };
+    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.
@@ -571,10 +497,10 @@ var TreeMultiset = /** @class */ (function (_super) {
      * @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.
      */
-    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; }); });
-    };
+    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.
@@ -582,11 +508,11 @@ var TreeMultiset = /** @class */ (function (_super) {
      * 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.
      */
-    TreeMultiset.prototype.morrisCount = function (pattern) {
+    morrisCount(pattern) {
         pattern = pattern || 'in';
-        var nodes = _super.prototype.morris.call(this, pattern, 'node');
-        return nodes.map(function (node) { return node.count; });
-    };
+        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.
@@ -597,11 +523,11 @@ var TreeMultiset = /** @class */ (function (_super) {
      * `'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.
      */
-    TreeMultiset.prototype.DFSIterativeCount = function (pattern, nodeOrPropertyName) {
+    DFSIterativeCount(pattern, nodeOrPropertyName) {
         pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
-        var nodes = _super.prototype.DFSIterative.call(this, pattern, 'node');
-        return nodes.map(function (node) { return node.count; });
-    };
+        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
@@ -612,59 +538,58 @@ var TreeMultiset = /** @class */ (function (_super) {
      * @returns The DFSCount method returns an array of numbers representing the count property of each node in the DFS
      * traversal.
      */
-    TreeMultiset.prototype.DFSCount = function (pattern, nodeOrPropertyName) {
+    DFSCount(pattern, nodeOrPropertyName) {
         pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
-        var nodes = _super.prototype.DFS.call(this, pattern, 'node');
-        return nodes.map(function (node) { return node.count; });
-    };
+        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.
      */
-    TreeMultiset.prototype.lesserSumCount = function (beginNode) {
-        var _this = this;
+    lesserSumCount(beginNode) {
         if (typeof beginNode === 'number')
             beginNode = this.get(beginNode, 'id');
         if (!beginNode)
             return 0;
         if (!this.root)
             return 0;
-        var id = beginNode.id;
-        var sum = 0;
+        const id = beginNode.id;
+        let sum = 0;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_5 = function (cur) {
-                var compared = _this._compare(cur.id, id);
+            const _traverse = (cur) => {
+                const 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_5(cur.right);
+                        _traverse(cur.right);
                     else
                         return;
                 }
                 else {
                     if (cur.left)
-                        _traverse_5(cur.left);
+                        _traverse(cur.left);
                     else
                         return;
                 }
             };
-            _traverse_5(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.id, id);
                     if (compared === types_1.CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSumCount(cur.right);
@@ -689,7 +614,7 @@ var TreeMultiset = /** @class */ (function (_super) {
             }
         }
         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.
@@ -698,36 +623,35 @@ var TreeMultiset = /** @class */ (function (_super) {
      * of each node should be increased.
      * @returns a boolean value.
      */
-    TreeMultiset.prototype.allGreaterNodesAddCount = function (node, delta) {
-        var _this = this;
+    allGreaterNodesAddCount(node, delta) {
         if (typeof node === 'number')
             node = this.get(node, 'id');
         if (!node)
             return false;
-        var id = node.id;
+        const id = node.id;
         if (!this.root)
             return false;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_6 = function (cur) {
-                var compared = _this._compare(cur.id, id);
+            const _traverse = (cur) => {
+                const 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_6(cur.left);
-                if (cur.right && _this._compare(cur.right.id, id) === types_1.CP.gt)
-                    _traverse_6(cur.right);
+                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);
             };
-            _traverse_6(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.id, id);
                     if (compared === types_1.CP.gt)
                         cur.count += delta;
                     if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
@@ -738,21 +662,20 @@ var TreeMultiset = /** @class */ (function (_super) {
             }
             return true;
         }
-    };
+    }
     /**
      * The clear() function clears the data and sets the count to 0.
      */
-    TreeMultiset.prototype.clear = function () {
-        _super.prototype.clear.call(this);
+    clear() {
+        super.clear();
         this._setCount(0);
-    };
+    }
     /**
      * The function "_setCount" is used to set the value of the "_count" property.
      * @param {number} v - number
      */
-    TreeMultiset.prototype._setCount = function (v) {
+    _setCount(v) {
         this._count = v;
-    };
-    return TreeMultiset;
-}(avl_tree_1.AVLTree));
+    }
+}
 exports.TreeMultiset = TreeMultiset;