avl-tree-typed 1.47.9 → 1.48.1

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

@@ -52,6 +52,12 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
      * @returns a new AVLTree object.
      */
     createTree(options?: AVLTreeOptions): TREE;
+    /**
+     * The function checks if an exemplar is an instance of AVLTreeNode.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
+     */
+    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.

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

@@ -63,6 +63,14 @@ class AVLTree extends bst_1.BST {
     createTree(options) {
         return new AVLTree([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
+    /**
+     * The function checks if an exemplar is an instance of AVLTreeNode.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
+     */
+    isNode(exemplar) {
+        return exemplar instanceof AVLTreeNode;
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.

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

@@ -72,6 +72,20 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns a new instance of a binary tree.
      */
     createTree(options?: Partial<BinaryTreeOptions>): TREE;
+    /**
+     * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the class N.
+     */
+    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    /**
+     * The function `exemplarToNode` converts an exemplar of a binary tree node into an actual node
+     * object.
+     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing the exemplar parameter of the
+     * function. It can be any type.
+     * @returns a value of type `N` (which represents a node), or `null`, or `undefined`.
+     */
+    exemplarToNode(exemplar: BTNodeExemplar<V, N>): N | null | undefined;
     /**
      * The function checks if a given value is an entry in a binary tree node.
      * @param kne - BTNodeExemplar<V, N> - A generic type representing a node in a binary tree. It has
@@ -446,6 +460,44 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * by the return type of the `callback` function.
      */
     morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function "keys" returns an array of keys from a given object.
+     * @returns an array of BTNKey objects.
+     */
+    keys(): BTNKey[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function "values" returns an array of values from a map-like object.
+     * @returns The `values()` method is returning an array of values (`V`) from the entries in the
+     * object.
+     */
+    values(): (V | undefined)[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a new tree object and copies all the nodes from the original tree to
+     * the new tree.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone(): TREE;
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)

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

@@ -117,6 +117,51 @@ class BinaryTree {
     createTree(options) {
         return new BinaryTree([], Object.assign({ iterationType: this.iterationType }, options));
     }
+    /**
+     * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the class N.
+     */
+    isNode(exemplar) {
+        return exemplar instanceof BinaryTreeNode;
+    }
+    /**
+     * The function `exemplarToNode` converts an exemplar of a binary tree node into an actual node
+     * object.
+     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing the exemplar parameter of the
+     * function. It can be any type.
+     * @returns a value of type `N` (which represents a node), or `null`, or `undefined`.
+     */
+    exemplarToNode(exemplar) {
+        if (exemplar === undefined)
+            return;
+        let node;
+        if (exemplar === null) {
+            node = null;
+        }
+        else if (this.isEntry(exemplar)) {
+            const [key, value] = exemplar;
+            if (key === undefined) {
+                return;
+            }
+            else if (key === null) {
+                node = null;
+            }
+            else {
+                node = this.createNode(key, value);
+            }
+        }
+        else if (this.isNode(exemplar)) {
+            node = exemplar;
+        }
+        else if (this.isNodeKey(exemplar)) {
+            node = this.createNode(exemplar);
+        }
+        else {
+            return;
+        }
+        return node;
+    }
     /**
      * The function checks if a given value is an entry in a binary tree node.
      * @param kne - BTNodeExemplar<V, N> - A generic type representing a node in a binary tree. It has
@@ -139,7 +184,10 @@ class BinaryTree {
      * @returns The function `add` returns the inserted node (`N`), `null`, or `undefined`.
      */
     add(keyOrNodeOrEntry) {
-        let inserted, needInsert;
+        let inserted;
+        const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+        if (newNode === undefined)
+            return;
         const _bfs = (root, newNode) => {
             const queue = new queue_1.Queue([root]);
             while (queue.size > 0) {
@@ -157,36 +205,12 @@ class BinaryTree {
                     queue.push(cur.right);
             }
         };
-        if (keyOrNodeOrEntry === null) {
-            needInsert = null;
-        }
-        else if (this.isNodeKey(keyOrNodeOrEntry)) {
-            needInsert = this.createNode(keyOrNodeOrEntry);
-        }
-        else if (keyOrNodeOrEntry instanceof BinaryTreeNode) {
-            needInsert = keyOrNodeOrEntry;
-        }
-        else if (this.isEntry(keyOrNodeOrEntry)) {
-            const [key, value] = keyOrNodeOrEntry;
-            if (key === undefined) {
-                return;
-            }
-            else if (key === null) {
-                needInsert = null;
-            }
-            else {
-                needInsert = this.createNode(key, value);
-            }
-        }
-        else {
-            return;
-        }
         if (this.root) {
-            inserted = _bfs(this.root, needInsert);
+            inserted = _bfs(this.root, newNode);
         }
         else {
-            this._setRoot(needInsert);
-            if (needInsert) {
+            this._setRoot(newNode);
+            if (newNode) {
                 this._size = 1;
             }
             else {
@@ -1380,6 +1404,60 @@ class BinaryTree {
         }
         return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function "keys" returns an array of keys from a given object.
+     * @returns an array of BTNKey objects.
+     */
+    keys() {
+        const keys = [];
+        for (const entry of this) {
+            keys.push(entry[0]);
+        }
+        return keys;
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function "values" returns an array of values from a map-like object.
+     * @returns The `values()` method is returning an array of values (`V`) from the entries in the
+     * object.
+     */
+    values() {
+        const values = [];
+        for (const entry of this) {
+            values.push(entry[1]);
+        }
+        return values;
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a new tree object and copies all the nodes from the original tree to
+     * the new tree.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+        const cloned = this.createTree();
+        this.bfs(node => cloned.add([node.key, node.value]));
+        return cloned;
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)

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

@@ -72,6 +72,19 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns a new instance of the BST class with the specified options.
      */
     createTree(options?: Partial<BSTOptions>): TREE;
+    /**
+     * The function checks if an exemplar is an instance of BSTNode.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
+     */
+    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    /**
+     * The function `exemplarToNode` takes an exemplar and returns a corresponding node if the exemplar
+     * is valid, otherwise it returns undefined.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a variable `node` which is of type `N` or `undefined`.
+     */
+    exemplarToNode(exemplar: BTNodeExemplar<V, N>): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.

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

@@ -100,6 +100,45 @@ class BST extends binary_tree_1.BinaryTree {
     createTree(options) {
         return new BST([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
+    /**
+     * The function checks if an exemplar is an instance of BSTNode.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
+     */
+    isNode(exemplar) {
+        return exemplar instanceof BSTNode;
+    }
+    /**
+     * The function `exemplarToNode` takes an exemplar and returns a corresponding node if the exemplar
+     * is valid, otherwise it returns undefined.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a variable `node` which is of type `N` or `undefined`.
+     */
+    exemplarToNode(exemplar) {
+        let node;
+        if (exemplar === null || exemplar === undefined) {
+            return;
+        }
+        else if (this.isNode(exemplar)) {
+            node = exemplar;
+        }
+        else if (this.isEntry(exemplar)) {
+            const [key, value] = exemplar;
+            if (key === undefined || key === null) {
+                return;
+            }
+            else {
+                node = this.createNode(key, value);
+            }
+        }
+        else if (this.isNodeKey(exemplar)) {
+            node = this.createNode(exemplar);
+        }
+        else {
+            return;
+        }
+        return node;
+    }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -115,28 +154,9 @@ class BST extends binary_tree_1.BinaryTree {
      * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
      */
     add(keyOrNodeOrEntry) {
-        if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) {
-            return undefined;
-        }
-        let newNode;
-        if (keyOrNodeOrEntry instanceof BSTNode) {
-            newNode = keyOrNodeOrEntry;
-        }
-        else if (this.isNodeKey(keyOrNodeOrEntry)) {
-            newNode = this.createNode(keyOrNodeOrEntry);
-        }
-        else if (this.isEntry(keyOrNodeOrEntry)) {
-            const [key, value] = keyOrNodeOrEntry;
-            if (key === undefined || key === null) {
-                return;
-            }
-            else {
-                newNode = this.createNode(key, value);
-            }
-        }
-        else {
+        const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+        if (newNode === undefined)
             return;
-        }
         if (this.root === undefined) {
             this._setRoot(newNode);
             this._size++;

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

@@ -58,6 +58,22 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * @returns a new instance of a RedBlackTree object.
      */
     createTree(options?: RBTreeOptions): TREE;
+    /**
+     * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
+     * class.
+     */
+    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    /**
+     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
+     * otherwise it returns undefined.
+     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
+     * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
+     * that is not a valid exemplar.
+     * @returns a variable `node` which is of type `N | undefined`.
+     */
+    exemplarToNode(exemplar: BTNodeExemplar<V, N>): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)

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

@@ -77,28 +77,32 @@ class RedBlackTree extends bst_1.BST {
         return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
+     * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
+     * class.
      */
+    isNode(exemplar) {
+        return exemplar instanceof RedBlackTreeNode;
+    }
     /**
-     * The function adds a node to a Red-Black Tree data structure.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @returns The method `add` returns either an instance of `N` (the node that was added) or
-     * `undefined`.
+     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
+     * otherwise it returns undefined.
+     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
+     * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
+     * that is not a valid exemplar.
+     * @returns a variable `node` which is of type `N | undefined`.
      */
-    add(keyOrNodeOrEntry) {
+    exemplarToNode(exemplar) {
         let node;
-        if (this.isNodeKey(keyOrNodeOrEntry)) {
-            node = this.createNode(keyOrNodeOrEntry, undefined, types_1.RBTNColor.RED);
-        }
-        else if (keyOrNodeOrEntry instanceof RedBlackTreeNode) {
-            node = keyOrNodeOrEntry;
-        }
-        else if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) {
+        if (exemplar === null || exemplar === undefined) {
             return;
         }
-        else if (this.isEntry(keyOrNodeOrEntry)) {
-            const [key, value] = keyOrNodeOrEntry;
+        else if (this.isNode(exemplar)) {
+            node = exemplar;
+        }
+        else if (this.isEntry(exemplar)) {
+            const [key, value] = exemplar;
             if (key === undefined || key === null) {
                 return;
             }
@@ -106,50 +110,69 @@ class RedBlackTree extends bst_1.BST {
                 node = this.createNode(key, value, types_1.RBTNColor.RED);
             }
         }
+        else if (this.isNodeKey(exemplar)) {
+            node = this.createNode(exemplar, undefined, types_1.RBTNColor.RED);
+        }
         else {
             return;
         }
-        node.left = this.Sentinel;
-        node.right = this.Sentinel;
+        return node;
+    }
+    /**
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     */
+    /**
+     * The function adds a node to a Red-Black Tree data structure.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
+     * @returns The method `add` returns either an instance of `N` (the node that was added) or
+     * `undefined`.
+     */
+    add(keyOrNodeOrEntry) {
+        const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+        if (newNode === undefined)
+            return;
+        newNode.left = this.Sentinel;
+        newNode.right = this.Sentinel;
         let y = undefined;
         let x = this.root;
         while (x !== this.Sentinel) {
             y = x;
             if (x) {
-                if (node.key < x.key) {
+                if (newNode.key < x.key) {
                     x = x.left;
                 }
-                else if (node.key > x.key) {
+                else if (newNode.key > x.key) {
                     x = x === null || x === void 0 ? void 0 : x.right;
                 }
                 else {
-                    if (node !== x) {
-                        this._replaceNode(x, node);
+                    if (newNode !== x) {
+                        this._replaceNode(x, newNode);
                     }
                     return;
                 }
             }
         }
-        node.parent = y;
+        newNode.parent = y;
         if (y === undefined) {
-            this._setRoot(node);
+            this._setRoot(newNode);
         }
-        else if (node.key < y.key) {
-            y.left = node;
+        else if (newNode.key < y.key) {
+            y.left = newNode;
         }
         else {
-            y.right = node;
+            y.right = newNode;
         }
-        if (node.parent === undefined) {
-            node.color = types_1.RBTNColor.BLACK;
+        if (newNode.parent === undefined) {
+            newNode.color = types_1.RBTNColor.BLACK;
             this._size++;
             return;
         }
-        if (node.parent.parent === undefined) {
+        if (newNode.parent.parent === undefined) {
             this._size++;
             return;
         }
-        this._fixInsert(node);
+        this._fixInsert(newNode);
         this._size++;
     }
     /**

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

@@ -41,6 +41,22 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      */
     createNode(key: BTNKey, value?: V, count?: number): N;
     createTree(options?: TreeMultimapOptions): TREE;
+    /**
+     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
+     * class.
+     */
+    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    /**
+     * The function `exemplarToNode` converts an exemplar object into a node object.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+     * the value type and `N` represents the node type.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the node should be created. If not provided, it defaults to 1.
+     * @returns a value of type `N` (the generic type parameter) or `undefined`.
+     */
+    exemplarToNode(exemplar: BTNodeExemplar<V, N>, count?: number): N | undefined;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -121,6 +137,18 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone(): TREE;
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.

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

@@ -51,6 +51,48 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     createTree(options) {
         return new TreeMultimap([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
+    /**
+     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
+     * class.
+     */
+    isNode(exemplar) {
+        return exemplar instanceof TreeMultimapNode;
+    }
+    /**
+     * The function `exemplarToNode` converts an exemplar object into a node object.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+     * the value type and `N` represents the node type.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the node should be created. If not provided, it defaults to 1.
+     * @returns a value of type `N` (the generic type parameter) or `undefined`.
+     */
+    exemplarToNode(exemplar, count = 1) {
+        let node;
+        if (exemplar === undefined || exemplar === null) {
+            return;
+        }
+        else if (this.isNode(exemplar)) {
+            node = exemplar;
+        }
+        else if (this.isEntry(exemplar)) {
+            const [key, value] = exemplar;
+            if (key === undefined || key === null) {
+                return;
+            }
+            else {
+                node = this.createNode(key, value, count);
+            }
+        }
+        else if (this.isNodeKey(exemplar)) {
+            node = this.createNode(exemplar, undefined, count);
+        }
+        else {
+            return;
+        }
+        return node;
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -68,28 +110,9 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * @returns either a node (`N`) or `undefined`.
      */
     add(keyOrNodeOrEntry, count = 1) {
-        let newNode;
-        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
+        const newNode = this.exemplarToNode(keyOrNodeOrEntry, count);
+        if (newNode === undefined)
             return;
-        }
-        else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
-            newNode = keyOrNodeOrEntry;
-        }
-        else if (this.isNodeKey(keyOrNodeOrEntry)) {
-            newNode = this.createNode(keyOrNodeOrEntry, undefined, count);
-        }
-        else if (this.isEntry(keyOrNodeOrEntry)) {
-            const [key, value] = keyOrNodeOrEntry;
-            if (key === undefined || key === null) {
-                return;
-            }
-            else {
-                newNode = this.createNode(key, value, count);
-            }
-        }
-        else {
-            return;
-        }
         const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
         const inserted = super.add(newNode);
         if (inserted) {
@@ -257,6 +280,22 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         super.clear();
         this._count = 0;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+        const cloned = this.createTree();
+        this.bfs(node => cloned.add([node.key, node.value], node.count));
+        return cloned;
+    }
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.