data-structure-typed 1.50.3 → 1.50.5

package/dist/umd/data-structure-typed.js

@@ -102,6 +102,8 @@ var dataStructureTyped = (() => {
   var src_exports = {};
   __export(src_exports, {
     AVLTree: () => AVLTree,
+    AVLTreeMultiMap: () => AVLTreeMultiMap,
+    AVLTreeMultiMapNode: () => AVLTreeMultiMapNode,
     AVLTreeNode: () => AVLTreeNode,
     AbstractEdge: () => AbstractEdge,
     AbstractGraph: () => AbstractGraph,
@@ -152,8 +154,8 @@ var dataStructureTyped = (() => {
     SkipListNode: () => SkipListNode,
     Stack: () => Stack,
     THUNK_SYMBOL: () => THUNK_SYMBOL,
-    TreeMultimap: () => TreeMultimap,
-    TreeMultimapNode: () => TreeMultimapNode,
+    TreeMultiMap: () => TreeMultiMap,
+    TreeMultiMapNode: () => TreeMultiMapNode,
     TreeNode: () => TreeNode,
     Trie: () => Trie,
     TrieNode: () => TrieNode,
@@ -176,10 +178,6 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/base/iterable-base.ts
   var IterableEntryBase = class {
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -297,6 +295,10 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -411,10 +413,6 @@ var dataStructureTyped = (() => {
       }
       return;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -511,6 +509,10 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -585,10 +587,6 @@ var dataStructureTyped = (() => {
       }
       return;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -1661,6 +1659,24 @@ var dataStructureTyped = (() => {
     get tail() {
       return this._tail;
     }
+    /**
+     * The above function returns the value of the first element in a linked list, or undefined if the
+     * list is empty.
+     * @returns The value of the first node in the linked list, or undefined if the linked list is empty.
+     */
+    get first() {
+      var _a;
+      return (_a = this.head) == null ? void 0 : _a.value;
+    }
+    /**
+     * The function returns the value of the last element in a linked list, or undefined if the list is
+     * empty.
+     * @returns The value of the last node in the linked list, or undefined if the linked list is empty.
+     */
+    get last() {
+      var _a;
+      return (_a = this.tail) == null ? void 0 : _a.value;
+    }
     /**
      * The function returns the size of an object.
      * @returns The size of the object, which is a number.
@@ -1693,19 +1709,18 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * Constant time, as it involves basic pointer adjustments.
-     * Constant space, as it only creates a new node.
      */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `push` function adds a new node with the given value to the end of a singly linked list.
-     * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
-     * any type (E) as specified in the generic type declaration of the class or function.
+     * The push function adds a new element to the end of a singly linked list.
+     * @param {E} element - The "element" parameter represents the value of the element that you want to
+     * add to the linked list.
+     * @returns The `push` method is returning a boolean value, `true`.
      */
-    push(value) {
-      const newNode = new SinglyLinkedListNode(value);
+    push(element) {
+      const newNode = new SinglyLinkedListNode(element);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -1716,21 +1731,6 @@ var dataStructureTyped = (() => {
       this._size++;
       return true;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `push` function adds a new node with the given value to the end of a singly linked list.
-     * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
-     * any type (E) as specified in the generic type declaration of the class or function.
-     */
-    addLast(value) {
-      return this.push(value);
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -1740,10 +1740,9 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
-     * pointers accordingly.
-     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-     * the linked list is empty, it returns `undefined`.
+     * The `pop` function removes and returns the value of the last element in a linked list.
+     * @returns The method is returning the value of the element that is being popped from the end of the
+     * list.
      */
     pop() {
       if (!this.head)
@@ -1765,22 +1764,6 @@ var dataStructureTyped = (() => {
       this._size--;
       return value;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
-     * pointers accordingly.
-     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-     * the linked list is empty, it returns `undefined`.
-     */
-    pollLast() {
-      return this.pop();
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1789,8 +1772,8 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `shift()` function removes and returns the value of the first node in a linked list.
-     * @returns The value of the node that is being removed from the beginning of the linked list.
+     * The `shift()` function removes and returns the value of the first element in a linked list.
+     * @returns The value of the removed node.
      */
     shift() {
       if (!this.head)
@@ -1808,26 +1791,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `pollFirst()` function removes and returns the value of the first node in a linked list.
-     * @returns The value of the node that is being removed from the beginning of the linked list.
-     */
-    pollFirst() {
-      return this.shift();
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The unshift function adds a new node with the given value to the beginning of a singly linked list.
-     * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
-     * linked list.
+     * The unshift function adds a new element to the beginning of a singly linked list.
+     * @param {E} element - The "element" parameter represents the value of the element that you want to
+     * add to the beginning of the singly linked list.
+     * @returns The `unshift` method is returning a boolean value, `true`.
      */
-    unshift(value) {
-      const newNode = new SinglyLinkedListNode(value);
+    unshift(element) {
+      const newNode = new SinglyLinkedListNode(element);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -1838,25 +1808,9 @@ var dataStructureTyped = (() => {
       this._size++;
       return true;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
-     * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
-     * linked list.
-     */
-    addFirst(value) {
-      return this.unshift(value);
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      */
     /**
      * Time Complexity: O(n)
@@ -2465,14 +2419,13 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The push function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
+     * The push function adds a new element to the end of a doubly linked list.
+     * @param {E} element - The "element" parameter represents the value that you want to add to the
+     * doubly linked list.
+     * @returns The `push` method is returning a boolean value, `true`.
      */
-    push(value) {
-      const newNode = new DoublyLinkedListNode(value);
+    push(element) {
+      const newNode = new DoublyLinkedListNode(element);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -2489,12 +2442,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pop()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns undefined.
+     * The `pop()` function removes and returns the value of the last element in a linked list.
+     * @returns The method is returning the value of the removed node.
      */
     pop() {
       if (!this.tail)
@@ -2515,12 +2464,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `shift()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
+     * The `shift()` function removes and returns the value of the first element in a doubly linked list.
+     * @returns The value of the removed node.
      */
     shift() {
       if (!this.head)
@@ -2541,15 +2486,13 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
+     * The unshift function adds a new element to the beginning of a doubly linked list.
+     * @param {E} element - The "element" parameter represents the value of the element that you want to
+     * add to the beginning of the doubly linked list.
+     * @returns The `unshift` method is returning a boolean value, `true`.
      */
-    unshift(value) {
-      const newNode = new DoublyLinkedListNode(value);
+    unshift(element) {
+      const newNode = new DoublyLinkedListNode(element);
       if (!this.head) {
         this._head = newNode;
         this._tail = newNode;
@@ -3033,65 +2976,6 @@ var dataStructureTyped = (() => {
       }
       return mappedList;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addLast function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
-     */
-    addLast(value) {
-      return this.push(value);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns undefined.
-     */
-    pollLast() {
-      return this.pop();
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
-     */
-    pollFirst() {
-      return this.shift();
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
-     */
-    addFirst(value) {
-      this.unshift(value);
-    }
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */
@@ -3758,64 +3642,6 @@ var dataStructureTyped = (() => {
       const spliced = this.elements.splice(index, 1);
       return spliced.length === 1;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
-     * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
-     */
-    peek() {
-      return this.first;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
-     * array is empty, it returns `undefined`.
-     */
-    peekLast() {
-      return this.last;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The enqueue function adds a value to the end of a queue.
-     * @param {E} value - The value parameter represents the value that you want to add to the queue.
-     */
-    enqueue(value) {
-      return this.push(value);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-     * @returns The method is returning a value of type E or undefined.
-     */
-    dequeue() {
-      return this.shift();
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -3961,35 +3787,6 @@ var dataStructureTyped = (() => {
     }
   };
   var LinkedListQueue = class _LinkedListQueue extends SinglyLinkedList {
-    /**
-     * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    get first() {
-      var _a;
-      return (_a = this.head) == null ? void 0 : _a.value;
-    }
-    /**
-     * The enqueue function adds a value to the end of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the queue.
-     */
-    enqueue(value) {
-      return this.push(value);
-    }
-    /**
-     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
-     */
-    dequeue() {
-      return this.shift();
-    }
-    /**
-     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    peek() {
-      return this.first;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4751,67 +4548,6 @@ var dataStructureTyped = (() => {
       }
       return newDeque;
     }
-    /**
-     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
-     * Space Complexity: O(n) - Due to potential resizing.
-     */
-    /**
-     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
-     * Space Complexity: O(n) - Due to potential resizing.
-     *
-     * The addLast function adds an element to the end of an array.
-     * @param {E} element - The element parameter represents the element that you want to add to the end of the
-     * data structure.
-     */
-    addLast(element) {
-      return this.push(element);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function "pollLast" removes and returns the last element of an array.
-     * @returns The last element of the array is being returned.
-     */
-    pollLast() {
-      return this.pop();
-    }
-    /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       *
-       * The "addFirst" function adds an element to the beginning of an array.
-       * @param {E} element - The parameter "element" represents the element that you want to add to the
-       * beginning of the data structure.
-       */
-    addFirst(element) {
-      return this.unshift(element);
-    }
-    /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       * /
-    
-       /**
-       * Time Complexity: O(1)
-       * Space Complexity: O(1)
-       *
-       * The function "pollFirst" removes and returns the first element of an array.
-       * @returns The method `pollFirst()` is returning the first element of the array after removing it
-       * from the beginning. If the array is empty, it will return `undefined`.
-       */
-    pollFirst() {
-      return this.shift();
-    }
     /**
        * Time Complexity: O(n)
        * Space Complexity: O(1)
@@ -5784,6 +5520,9 @@ var dataStructureTyped = (() => {
     set vertexMap(v) {
       this._vertexMap = v;
     }
+    get size() {
+      return this._vertexMap.size;
+    }
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -10221,11 +9960,9 @@ var dataStructureTyped = (() => {
           const compared = this._compare(cur.key, targetKey);
           if (compared === lesserOrGreater)
             ans.push(callback(cur));
-          if (!cur.left && !cur.right)
-            return;
-          if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+          if (this.isRealNode(cur.left))
             _traverse(cur.left);
-          if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+          if (this.isRealNode(cur.right))
             _traverse(cur.right);
         };
         _traverse(this.root);
@@ -10234,13 +9971,13 @@ var dataStructureTyped = (() => {
         const queue = new Queue([this.root]);
         while (queue.size > 0) {
           const cur = queue.shift();
-          if (cur) {
+          if (this.isRealNode(cur)) {
             const compared = this._compare(cur.key, targetKey);
             if (compared === lesserOrGreater)
               ans.push(callback(cur));
-            if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+            if (this.isRealNode(cur.left))
               queue.push(cur.left);
-            if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+            if (this.isRealNode(cur.right))
               queue.push(cur.right);
           }
         }
@@ -11847,12 +11584,12 @@ var dataStructureTyped = (() => {
      */
     _fixInsert(k) {
       let u;
-      while (k.parent && k.parent.color === 1) {
+      while (k.parent && k.parent.color === 1 /* RED */) {
         if (k.parent.parent && k.parent === k.parent.parent.right) {
           u = k.parent.parent.left;
-          if (u && u.color === 1) {
-            u.color = 0 /* BLACK */;
+          if (u && u.color === 1 /* RED */) {
             k.parent.color = 0 /* BLACK */;
+            u.color = 0 /* BLACK */;
             k.parent.parent.color = 1 /* RED */;
             k = k.parent.parent;
           } else {
@@ -11860,15 +11597,17 @@ var dataStructureTyped = (() => {
               k = k.parent;
               this._rightRotate(k);
             }
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
+            if (k.parent.color === 1 /* RED */) {
+              k.parent.color = 0 /* BLACK */;
+              k.parent.parent.color = 1 /* RED */;
+            }
             this._leftRotate(k.parent.parent);
           }
         } else {
           u = k.parent.parent.right;
-          if (u && u.color === 1) {
-            u.color = 0 /* BLACK */;
+          if (u && u.color === 1 /* RED */) {
             k.parent.color = 0 /* BLACK */;
+            u.color = 0 /* BLACK */;
             k.parent.parent.color = 1 /* RED */;
             k = k.parent.parent;
           } else {
@@ -11876,8 +11615,10 @@ var dataStructureTyped = (() => {
               k = k.parent;
               this._leftRotate(k);
             }
-            k.parent.color = 0 /* BLACK */;
-            k.parent.parent.color = 1 /* RED */;
+            if (k.parent.color === 1 /* RED */) {
+              k.parent.color = 0 /* BLACK */;
+              k.parent.parent.color = 1 /* RED */;
+            }
             this._rightRotate(k.parent.parent);
           }
         }
@@ -11996,8 +11737,8 @@ var dataStructureTyped = (() => {
     }
   };
 
-  // src/data-structures/binary-tree/tree-multimap.ts
-  var TreeMultimapNode = class extends AVLTreeNode {
+  // src/data-structures/binary-tree/avl-tree-multi-map.ts
+  var AVLTreeMultiMapNode = class extends AVLTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -12029,7 +11770,7 @@ var dataStructureTyped = (() => {
       this._count = value;
     }
   };
-  var TreeMultimap = class _TreeMultimap extends AVLTree {
+  var AVLTreeMultiMap = class _AVLTreeMultiMap extends AVLTree {
     constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
@@ -12057,19 +11798,19 @@ var dataStructureTyped = (() => {
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key, value, count) {
-      return new TreeMultimapNode(key, value, count);
+      return new AVLTreeMultiMapNode(key, value, count);
     }
     /**
-     * The function creates a new TreeMultimap object with the specified options and returns it.
+     * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
      * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `TreeMultimap` object. It can include properties such as
+     * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
      * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
      * the tree, respectively. These properties can be
-     * @returns a new instance of the `TreeMultimap` class, with the provided options merged with the
+     * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
      * default options. The returned value is casted as `TREE`.
      */
     createTree(options) {
-      return new _TreeMultimap([], __spreadValues({
+      return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
         variant: this.variant
       }, options));
@@ -12106,13 +11847,13 @@ var dataStructureTyped = (() => {
       return node;
     }
     /**
-     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * The function checks if an keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode class.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode
      * class.
      */
     isNode(keyOrNodeOrEntry) {
-      return keyOrNodeOrEntry instanceof TreeMultimapNode;
+      return keyOrNodeOrEntry instanceof AVLTreeMultiMapNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -12344,6 +12085,372 @@ var dataStructureTyped = (() => {
     }
   };
 
+  // src/data-structures/binary-tree/tree-multi-map.ts
+  var TreeMultiMapNode = class extends RedBlackTreeNode {
+    /**
+     * The constructor function initializes an instance of a class with a key, value, and count.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key for the
+     * constructor. It is required and must be provided when creating an instance of the class.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
+     * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
+     * 1.
+     */
+    constructor(key, value, count = 1) {
+      super(key, value);
+      __publicField(this, "_count", 1);
+      this.count = count;
+    }
+    /**
+     * The function returns the value of the private variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count() {
+      return this._count;
+    }
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value) {
+      this._count = value;
+    }
+  };
+  var TreeMultiMap = class _TreeMultiMap extends RedBlackTree {
+    /**
+     * The constructor function initializes a new instance of the TreeMultiMap class with optional
+     * initial keys, nodes, or entries.
+     * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
+     * contain keys, nodes, or entries. It is used to initialize the TreeMultiMap with the provided keys,
+     * nodes, or entries.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor. It allows you to customize the behavior of the `TreeMultiMap` instance.
+     */
+    constructor(keysOrNodesOrEntries = [], options) {
+      super([], options);
+      __publicField(this, "_count", 0);
+      if (keysOrNodesOrEntries)
+        this.addMany(keysOrNodesOrEntries);
+    }
+    // TODO the _count is not accurate after nodes count modified
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree structure.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    get count() {
+      let sum = 0;
+      this.dfs((node) => sum += node.count);
+      return sum;
+    }
+    /**
+     * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+     * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
+     * which is a generic type that can be replaced with any specific type when using the function.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the node. It is of type `V`, which can be any data type.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a
+     * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
+     * default to 1.
+     * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+     */
+    createNode(key, value, count) {
+      return new TreeMultiMapNode(key, value, count);
+    }
+    /**
+     * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `TreeMultiMap`. It can include properties such as
+     * `keyComparator`, `valueComparator`, `allowDuplicates`, etc.
+     * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
+     * existing `iterationType` option. The returned value is casted as `TREE`.
+     */
+    createTree(options) {
+      return new _TreeMultiMap([], __spreadValues({
+        iterationType: this.iterationType
+      }, options));
+    }
+    /**
+     * The function `keyValueOrEntryToNode` takes a key, value, and count and returns a node if the input
+     * is valid.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+     * NODE>`. It can accept three types of values:
+     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
+     * value associated with a key in a key-value pair.
+     * @param [count=1] - The count parameter is an optional parameter that specifies the number of times
+     * the key-value pair should be added to the node. If not provided, it defaults to 1.
+     * @returns a NODE object or undefined.
+     */
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value, count = 1) {
+      let node;
+      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
+        return;
+      } else if (this.isNode(keyOrNodeOrEntry)) {
+        node = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value2] = keyOrNodeOrEntry;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          node = this.createNode(key, value2, count);
+        }
+      } else if (!this.isNode(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value, count);
+      } else {
+        return;
+      }
+      return node;
+    }
+    /**
+     * The function "isNode" checks if a given key, node, or entry is an instance of the TreeMultiMapNode
+     * class.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+     * NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntry` is an instance
+     * of the `TreeMultiMapNode` class.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof TreeMultiMapNode;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function overrides the add method in TypeScript and adds a new node to the data structure.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * data structure.
+     * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
+     * be added to the data structure. By default, it is set to 1, meaning that the key-value pair will
+     * be added once. However, you can specify a different value for `count` if you want to add
+     * @returns a boolean value.
+     */
+    add(keyOrNodeOrEntry, value, count = 1) {
+      const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
+      if (newNode === void 0)
+        return false;
+      const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
+      const inserted = super.add(newNode);
+      if (inserted) {
+        this._count += orgNodeCount;
+      }
+      return true;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `delete` function in a TypeScript class is used to delete nodes from a binary tree based on a
+     * given identifier, and it returns an array of results containing information about the deleted
+     * nodes.
+     * @param {ReturnType<C> | null | undefined} identifier - The identifier parameter is the value used
+     * to identify the node to be deleted. It can be of any type that is returned by the callback
+     * function. It can also be null or undefined if no node needs to be deleted.
+     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
+     * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
+     * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+     * used
+     * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
+     * node when performing deletion. If set to true, the count of the target node will not be considered
+     * and the node will be deleted regardless of its count. If set to false (default), the count of the
+     * target node will be decremented
+     * @returns an array of BinaryTreeDeleteResult<NODE> objects.
+     */
+    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+      const deleteResults = [];
+      if (identifier === null)
+        return deleteResults;
+      const deleteHelper = (node) => {
+        let targetNode = this._Sentinel;
+        let currentNode;
+        while (node !== this._Sentinel) {
+          if (node && callback(node) === identifier) {
+            targetNode = node;
+          }
+          if (node && identifier && callback(node) <= identifier) {
+            node = node.right;
+          } else {
+            node = node == null ? void 0 : node.left;
+          }
+        }
+        if (targetNode === this._Sentinel) {
+          return;
+        }
+        if (ignoreCount || targetNode.count <= 1) {
+          let parentNode = targetNode;
+          let parentNodeOriginalColor = parentNode.color;
+          if (targetNode.left === this._Sentinel) {
+            currentNode = targetNode.right;
+            this._rbTransplant(targetNode, targetNode.right);
+          } else if (targetNode.right === this._Sentinel) {
+            currentNode = targetNode.left;
+            this._rbTransplant(targetNode, targetNode.left);
+          } else {
+            parentNode = this.getLeftMost(targetNode.right);
+            parentNodeOriginalColor = parentNode.color;
+            currentNode = parentNode.right;
+            if (parentNode.parent === targetNode) {
+              currentNode.parent = parentNode;
+            } else {
+              this._rbTransplant(parentNode, parentNode.right);
+              parentNode.right = targetNode.right;
+              parentNode.right.parent = parentNode;
+            }
+            this._rbTransplant(targetNode, parentNode);
+            parentNode.left = targetNode.left;
+            parentNode.left.parent = parentNode;
+            parentNode.color = targetNode.color;
+          }
+          if (parentNodeOriginalColor === 0 /* BLACK */) {
+            this._fixDelete(currentNode);
+          }
+          this._size--;
+          this._count -= targetNode.count;
+          deleteResults.push({ deleted: targetNode, needBalanced: void 0 });
+        } else {
+          targetNode.count--;
+          this._count--;
+        }
+      };
+      deleteHelper(this.root);
+      return deleteResults;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "clear" function overrides the parent class's "clear" function and also resets the count to
+     * zero.
+     */
+    clear() {
+      super.clear();
+      this._count = 0;
+    }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     *
+     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+     * tree using either a recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building the balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType = this.iterationType) {
+      const sorted = this.dfs((node) => node, "in"), n = sorted.length;
+      if (sorted.length < 1)
+        return false;
+      this.clear();
+      if (iterationType === "RECURSIVE" /* RECURSIVE */) {
+        const buildBalanceBST = (l, r) => {
+          if (l > r)
+            return;
+          const m = l + Math.floor((r - l) / 2);
+          const midNode = sorted[m];
+          this.add(midNode.key, midNode.value, midNode.count);
+          buildBalanceBST(l, m - 1);
+          buildBalanceBST(m + 1, r);
+        };
+        buildBalanceBST(0, n - 1);
+        return true;
+      } else {
+        const stack = [[0, n - 1]];
+        while (stack.length > 0) {
+          const popped = stack.pop();
+          if (popped) {
+            const [l, r] = popped;
+            if (l <= r) {
+              const m = l + Math.floor((r - l) / 2);
+              const midNode = sorted[m];
+              this.add(midNode.key, midNode.value, midNode.count);
+              stack.push([m + 1, r]);
+              stack.push([l, m - 1]);
+            }
+          }
+        }
+        return true;
+      }
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the clone method to create 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;
+    }
+    /**
+     * The function swaps the properties of two nodes in a binary search tree.
+     * @param srcNode - The source node that needs to be swapped with the destination node. It can be
+     * either a key or a node object.
+     * @param destNode - The `destNode` parameter is the node in the binary search tree where the
+     * properties will be swapped with the `srcNode`.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     * If both `srcNode` and `destNode` are valid nodes, the method swaps their `key`, `value`, `count`,
+     * and `color` properties. If the swapping is successful, the method returns the modified `destNode`.
+     * If either `srcNode` or `destNode` is
+     */
+    _swapProperties(srcNode, destNode) {
+      srcNode = this.ensureNode(srcNode);
+      destNode = this.ensureNode(destNode);
+      if (srcNode && destNode) {
+        const { key, value, count, color } = destNode;
+        const tempNode = this.createNode(key, value, count);
+        if (tempNode) {
+          tempNode.color = color;
+          destNode.key = srcNode.key;
+          destNode.value = srcNode.value;
+          destNode.count = srcNode.count;
+          destNode.color = srcNode.color;
+          srcNode.key = tempNode.key;
+          srcNode.value = tempNode.value;
+          srcNode.count = tempNode.count;
+          srcNode.color = tempNode.color;
+        }
+        return destNode;
+      }
+      return void 0;
+    }
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
+    _replaceNode(oldNode, newNode) {
+      newNode.count = oldNode.count + newNode.count;
+      return super._replaceNode(oldNode, newNode);
+    }
+  };
+
   // src/data-structures/tree/tree.ts
   var TreeNode = class _TreeNode {
     /**