data-structure-typed 1.12.11 → 1.15.0

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import type { BinaryTreeDeleted, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName, ResultsByProperty } from '../types';
 export declare enum FamilyPosition {
@@ -8,36 +11,74 @@ export declare enum FamilyPosition {
     left = 1,
     right = 2
 }
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
 export declare enum LoopType {
     iterative = 1,
     recursive = 2
 }
 export declare class BinaryTreeNode<T> {
-    constructor(id: BinaryTreeNodeId, val: T, count?: number);
     protected _id: BinaryTreeNodeId;
     get id(): BinaryTreeNodeId;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getId(): BinaryTreeNodeId;
     set id(v: BinaryTreeNodeId);
     protected _val: T;
     get val(): T;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getVal(): T;
     set val(v: T);
     protected _left?: BinaryTreeNode<T> | null;
     get left(): BinaryTreeNode<T> | null | undefined;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getLeft(): BinaryTreeNode<T> | null | undefined;
     set left(v: BinaryTreeNode<T> | null | undefined);
     protected _right?: BinaryTreeNode<T> | null;
     get right(): BinaryTreeNode<T> | null | undefined;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getRight(): BinaryTreeNode<T> | null | undefined;
     set right(v: BinaryTreeNode<T> | null | undefined);
     protected _parent: BinaryTreeNode<T> | null | undefined;
     get parent(): BinaryTreeNode<T> | null | undefined;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getParent(): BinaryTreeNode<T> | null | undefined;
     set parent(v: BinaryTreeNode<T> | null | undefined);
     protected _familyPosition: FamilyPosition;
     get familyPosition(): FamilyPosition;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getFamilyPosition(): FamilyPosition;
     set familyPosition(v: FamilyPosition);
     protected _count: number;
     get count(): number;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getCount(): number;
     set count(v: number);
     protected _height: number;
     get height(): number;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getHeight(): number;
     set height(v: number);
+    constructor(id: BinaryTreeNodeId, val: T, count?: number);
     swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T>;
     clone(): BinaryTreeNode<T>;
 }
@@ -63,12 +104,25 @@ export declare class BinaryTree<T> {
     });
     protected _root: BinaryTreeNode<T> | null;
     get root(): BinaryTreeNode<T> | null;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Getters (using the same name as the property) while utilizing separate method names for Setters.
+     * @returns The method is returning either a BinaryTreeNode object of type T or null.
+     */
+    getRoot(): BinaryTreeNode<T> | null;
     protected set root(v: BinaryTreeNode<T> | null);
     protected _size: number;
     get size(): number;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getSize(): number;
     protected set size(v: number);
     protected _count: number;
     get count(): number;
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    getCount(): number;
     protected set count(v: number);
     /**
      * The function creates a new binary tree node with the given id, value, and count, or returns null if the value is
@@ -93,34 +147,34 @@ export declare class BinaryTree<T> {
      */
     isEmpty(): boolean;
     /**
-     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
-     * `null`. It represents the node that needs to be inserted into the binary tree.
-     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
-     * will be inserted as a child.
-     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
-     */
-    putTo(newNode: BinaryTreeNode<T> | null, parent: BinaryTreeNode<T>): BinaryTreeNode<T> | null | undefined;
-    /**
-     * The `put` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
+     * The `add` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
      * already exists.
      * @param {BinaryTreeNodeId} id - The id parameter is the identifier of the binary tree node. It is used to uniquely
      * identify each node in the binary tree.
      * @param {T} val - The value to be inserted into the binary tree.
      * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
      * value should be inserted into the binary tree. If not provided, it defaults to 1.
-     * @returns The function `put` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
+     * @returns The function `add` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
      * is inserted, or `undefined` if the insertion fails.
      */
-    put(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined;
+    add(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined;
+    /**
+     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
+     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
+     * `null`. It represents the node that needs to be inserted into the binary tree.
+     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
+     * will be inserted as a child.
+     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
+     */
+    addTo(newNode: BinaryTreeNode<T> | null, parent: BinaryTreeNode<T>): BinaryTreeNode<T> | null | undefined;
     /**
-     * The `insertMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
+     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
      * @param {T[] | BinaryTreeNode<T>[]} data - The `data` parameter can be either an array of elements of type `T` or an
      * array of `BinaryTreeNode<T>` objects.
-     * @returns The function `insertMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
+     * @returns The function `addMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
      */
-    insertMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[];
+    addMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[];
     /**
      * The `fill` function clears the current data and inserts new data, returning a boolean indicating if the insertion
      * was successful.

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

@@ -1,7 +1,10 @@
 "use strict";
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
@@ -32,13 +35,20 @@ var __read = (this && this.__read) || function (o, n) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryTree = exports.BinaryTreeNode = exports.LoopType = exports.FamilyPosition = void 0;
-var trampoline_1 = require("../../utils/trampoline");
+var utils_1 = require("../../utils");
+/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
 var FamilyPosition;
 (function (FamilyPosition) {
     FamilyPosition[FamilyPosition["root"] = 0] = "root";
     FamilyPosition[FamilyPosition["left"] = 1] = "left";
     FamilyPosition[FamilyPosition["right"] = 2] = "right";
 })(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
 var LoopType;
 (function (LoopType) {
     LoopType[LoopType["iterative"] = 1] = "iterative";
@@ -63,6 +73,12 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTreeNode.prototype.getId = function () {
+        return this._id;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "val", {
         get: function () {
             return this._val;
@@ -73,6 +89,12 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTreeNode.prototype.getVal = function () {
+        return this._val;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "left", {
         get: function () {
             return this._left;
@@ -87,6 +109,12 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTreeNode.prototype.getLeft = function () {
+        return this._left;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "right", {
         get: function () {
             return this._right;
@@ -101,6 +129,12 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTreeNode.prototype.getRight = function () {
+        return this._right;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "parent", {
         get: function () {
             return this._parent;
@@ -111,6 +145,12 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTreeNode.prototype.getParent = function () {
+        return this._parent;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "familyPosition", {
         get: function () {
             return this._familyPosition;
@@ -121,6 +161,12 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTreeNode.prototype.getFamilyPosition = function () {
+        return this._familyPosition;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "count", {
         get: function () {
             return this._count;
@@ -131,6 +177,12 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTreeNode.prototype.getCount = function () {
+        return this._count;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "height", {
         get: function () {
             return this._height;
@@ -141,6 +193,12 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTreeNode.prototype.getHeight = function () {
+        return this._height;
+    };
     BinaryTreeNode.prototype.swapLocation = function (swapNode) {
         var val = swapNode.val, count = swapNode.count, height = swapNode.height;
         var tempNode = new BinaryTreeNode(swapNode.id, val);
@@ -203,6 +261,13 @@ var BinaryTree = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Getters (using the same name as the property) while utilizing separate method names for Setters.
+     * @returns The method is returning either a BinaryTreeNode object of type T or null.
+     */
+    BinaryTree.prototype.getRoot = function () {
+        return this._root;
+    };
     Object.defineProperty(BinaryTree.prototype, "size", {
         get: function () {
             return this._size;
@@ -213,6 +278,12 @@ var BinaryTree = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTree.prototype.getSize = function () {
+        return this._size;
+    };
     Object.defineProperty(BinaryTree.prototype, "count", {
         get: function () {
             return this._count;
@@ -223,6 +294,12 @@ var BinaryTree = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     */
+    BinaryTree.prototype.getCount = function () {
+        return this._count;
+    };
     /**
      * The function creates a new binary tree node with the given id, value, and count, or returns null if the value is
      * null.
@@ -255,60 +332,17 @@ var BinaryTree = /** @class */ (function () {
         return this.size === 0;
     };
     /**
-     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
-     * `null`. It represents the node that needs to be inserted into the binary tree.
-     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
-     * will be inserted as a child.
-     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
-     */
-    BinaryTree.prototype.putTo = function (newNode, parent) {
-        var _a, _b;
-        if (parent) {
-            if (parent.left === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                    newNode.familyPosition = FamilyPosition.left;
-                }
-                parent.left = newNode;
-                if (newNode !== null) {
-                    this.size++;
-                    this.count += (_a = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _a !== void 0 ? _a : 0;
-                }
-                return parent.left;
-            }
-            else if (parent.right === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                    newNode.familyPosition = FamilyPosition.right;
-                }
-                parent.right = newNode;
-                if (newNode !== null) {
-                    this.size++;
-                    this.count += (_b = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _b !== void 0 ? _b : 0;
-                }
-                return parent.right;
-            }
-            else {
-                return;
-            }
-        }
-        else {
-            return;
-        }
-    };
-    /**
-     * The `put` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
+     * The `add` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
      * already exists.
      * @param {BinaryTreeNodeId} id - The id parameter is the identifier of the binary tree node. It is used to uniquely
      * identify each node in the binary tree.
      * @param {T} val - The value to be inserted into the binary tree.
      * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
      * value should be inserted into the binary tree. If not provided, it defaults to 1.
-     * @returns The function `put` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
+     * @returns The function `add` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
      * is inserted, or `undefined` if the insertion fails.
      */
-    BinaryTree.prototype.put = function (id, val, count) {
+    BinaryTree.prototype.add = function (id, val, count) {
         var _this = this;
         count = count !== null && count !== void 0 ? count : 1;
         var _bfs = function (root, newNode) {
@@ -316,7 +350,7 @@ var BinaryTree = /** @class */ (function () {
             while (queue.length > 0) {
                 var cur = queue.shift();
                 if (cur) {
-                    var inserted_1 = _this.putTo(newNode, cur);
+                    var inserted_1 = _this.addTo(newNode, cur);
                     if (inserted_1 !== undefined)
                         return inserted_1;
                     if (cur.left)
@@ -356,13 +390,56 @@ var BinaryTree = /** @class */ (function () {
         return inserted;
     };
     /**
-     * The `insertMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
+     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
+     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
+     * `null`. It represents the node that needs to be inserted into the binary tree.
+     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
+     * will be inserted as a child.
+     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
+     */
+    BinaryTree.prototype.addTo = function (newNode, parent) {
+        var _a, _b;
+        if (parent) {
+            if (parent.left === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                    newNode.familyPosition = FamilyPosition.left;
+                }
+                parent.left = newNode;
+                if (newNode !== null) {
+                    this.size++;
+                    this.count += (_a = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _a !== void 0 ? _a : 0;
+                }
+                return parent.left;
+            }
+            else if (parent.right === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                    newNode.familyPosition = FamilyPosition.right;
+                }
+                parent.right = newNode;
+                if (newNode !== null) {
+                    this.size++;
+                    this.count += (_b = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _b !== void 0 ? _b : 0;
+                }
+                return parent.right;
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+    };
+    /**
+     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
      * @param {T[] | BinaryTreeNode<T>[]} data - The `data` parameter can be either an array of elements of type `T` or an
      * array of `BinaryTreeNode<T>` objects.
-     * @returns The function `insertMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
+     * @returns The function `addMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
      */
-    BinaryTree.prototype.insertMany = function (data) {
+    BinaryTree.prototype.addMany = function (data) {
         var e_1, _a, e_2, _b;
         var _c;
         var inserted = [];
@@ -387,33 +464,33 @@ var BinaryTree = /** @class */ (function () {
                 var item = data_2_1.value;
                 var count = this._isDuplicatedVal ? 1 : map.get(item);
                 if (item instanceof BinaryTreeNode) {
-                    inserted.push(this.put(item.id, item.val, item.count));
+                    inserted.push(this.add(item.id, item.val, item.count));
                 }
                 else if (typeof item === 'number' && !this._autoIncrementId) {
                     if (!this._isDuplicatedVal) {
                         if (map.get(item) !== undefined) {
-                            inserted.push(this.put(item, item, count));
+                            inserted.push(this.add(item, item, count));
                             map.delete(item);
                         }
                     }
                     else {
-                        inserted.push(this.put(item, item, 1));
+                        inserted.push(this.add(item, item, 1));
                     }
                 }
                 else {
                     if (item !== null) {
                         if (!this._isDuplicatedVal) {
                             if (map.get(item) !== undefined) {
-                                inserted.push(this.put(++this._maxId, item, count));
+                                inserted.push(this.add(++this._maxId, item, count));
                                 map.delete(item);
                             }
                         }
                         else {
-                            inserted.push(this.put(++this._maxId, item, 1));
+                            inserted.push(this.add(++this._maxId, item, 1));
                         }
                     }
                     else {
-                        inserted.push(this.put(Number.MAX_SAFE_INTEGER, item, 0));
+                        inserted.push(this.add(Number.MAX_SAFE_INTEGER, item, 0));
                     }
                 }
             }
@@ -436,7 +513,7 @@ var BinaryTree = /** @class */ (function () {
      */
     BinaryTree.prototype.fill = function (data) {
         this.clear();
-        return data.length === this.insertMany(data).length;
+        return data.length === this.addMany(data).length;
     };
     /**
      * The function removes a node from a binary tree and returns information about the deleted node.
@@ -718,7 +795,7 @@ var BinaryTree = /** @class */ (function () {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            var _traverse_3 = (0, trampoline_1.trampoline)(function (cur) {
+            var _traverse_3 = (0, utils_1.trampoline)(function (cur) {
                 if (!cur.left)
                     return cur;
                 return _traverse_3.cont(cur.left);
@@ -748,7 +825,7 @@ var BinaryTree = /** @class */ (function () {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            var _traverse_5 = (0, trampoline_1.trampoline)(function (cur) {
+            var _traverse_5 = (0, utils_1.trampoline)(function (cur) {
                 if (!cur.right)
                     return cur;
                 return _traverse_5.cont(cur.right);