data-structure-typed 1.53.9 → 1.54.0

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

@@ -7389,6 +7389,9 @@ var dataStructureTyped = (() => {
       __publicField(this, "parent");
       __publicField(this, "_left");
       __publicField(this, "_right");
+      __publicField(this, "_height", 0);
+      __publicField(this, "_color", "BLACK");
+      __publicField(this, "_count", 1);
       this.key = key;
       this.value = value;
     }
@@ -7410,6 +7413,24 @@ var dataStructureTyped = (() => {
       }
       this._right = v;
     }
+    get height() {
+      return this._height;
+    }
+    set height(value) {
+      this._height = value;
+    }
+    get color() {
+      return this._color;
+    }
+    set color(value) {
+      this._color = value;
+    }
+    get count() {
+      return this._count;
+    }
+    set count(value) {
+      this._count = value;
+    }
     get familyPosition() {
       const that = this;
       if (!this.parent) {
@@ -7486,18 +7507,12 @@ var dataStructureTyped = (() => {
       return new BinaryTreeNode(key, this._isMapMode ? void 0 : value);
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `createTree` function creates a new binary tree based on the provided options.
-     * @param [options] - The `options` parameter in the `createTree` method is of type
-     * `BinaryTreeOptions<K, V, R>`. This type likely contains configuration options for creating a
-     * binary tree, such as the iteration type, whether the tree is in map mode, and functions for
-     * converting entries.
-     * @returns The `createTree` method is returning an instance of the `BinaryTree` class with the
-     * provided options. The method is creating a new `BinaryTree` object with an empty array as the
-     * initial data, and then setting various options such as `iterationType`, `isMapMode`, and
-     * `toEntryFn` based on the current object's properties and the provided `options`. Finally, it
+     * The function creates a binary tree with the specified options.
+     * @param [options] - The `options` parameter in the `createTree` function is an optional parameter
+     * that allows you to provide partial configuration options for creating a binary tree. It is of type
+     * `Partial<BinaryTreeOptions<K, V, R>>`, which means you can pass in an object containing a subset
+     * of properties
+     * @returns A new instance of a binary tree with the specified options is being returned.
      */
     createTree(options) {
       return new _BinaryTree([], __spreadValues({
@@ -7506,6 +7521,40 @@ var dataStructureTyped = (() => {
         toEntryFn: this._toEntryFn
       }, options));
     }
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
+     * or returns null.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
+     * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
+     * node, an entry
+     * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
+     * an optional parameter of type `V`. It represents the value associated with the key in the node
+     * being created. If a `value` is provided, it will be used when creating the node. If
+     * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
+     * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
+     * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
+     * value.
+     */
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+      if (keyNodeEntryOrRaw === void 0) return [void 0, void 0];
+      if (keyNodeEntryOrRaw === null) return [null, void 0];
+      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+      if (this.isEntry(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = keyNodeEntryOrRaw;
+        if (key === void 0) return [void 0, void 0];
+        else if (key === null) return [null, void 0];
+        const finalValue = value != null ? value : entryValue;
+        return [this.createNode(key, finalValue), finalValue];
+      }
+      if (this.isRaw(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+        const finalValue = value != null ? value : entryValue;
+        if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
+      }
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
+      return [void 0, void 0];
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -8799,40 +8848,6 @@ var dataStructureTyped = (() => {
     print(options, startNode = this._root) {
       console.log(this.toVisual(startNode, options));
     }
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
-     * or returns null.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
-     * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
-     * node, an entry
-     * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
-     * an optional parameter of type `V`. It represents the value associated with the key in the node
-     * being created. If a `value` is provided, it will be used when creating the node. If
-     * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
-     * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
-     * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
-     * value.
-     */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-      if (keyNodeEntryOrRaw === void 0) return [void 0, void 0];
-      if (keyNodeEntryOrRaw === null) return [null, void 0];
-      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-      if (this.isEntry(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = keyNodeEntryOrRaw;
-        if (key === void 0) return [void 0, void 0];
-        else if (key === null) return [null, void 0];
-        const finalValue = value != null ? value : entryValue;
-        return [this.createNode(key, finalValue), finalValue];
-      }
-      if (this.isRaw(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-        const finalValue = value != null ? value : entryValue;
-        if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
-      }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
-      return [void 0, void 0];
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -9340,21 +9355,6 @@ var dataStructureTyped = (() => {
     get isReverse() {
       return this._isReverse;
     }
-    /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
-     */
-    get comparator() {
-      return this._comparator;
-    }
-    /**
-     * This function returns the value of the `_specifyComparable` property.
-     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
-     * `_specifyComparable` property.
-     */
-    get specifyComparable() {
-      return this._specifyComparable;
-    }
     /**
      * The function creates a new BSTNode with the given key and value and returns it.
      * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
@@ -9367,17 +9367,12 @@ var dataStructureTyped = (() => {
       return new BSTNode(key, this._isMapMode ? void 0 : value);
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `createTree` function in TypeScript overrides the default options with the provided options to
-     * create a new Binary Search Tree.
-     * @param [options] - The `options` parameter in the `createTree` method is an optional object that
-     * can contain the following properties:
-     * @returns A new instance of a Binary Search Tree (BST) is being returned with the specified options
-     * and properties inherited from the current instance.
+     * The function creates a new binary search tree with the specified options.
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which has the
+     * following properties:
+     * @returns a new instance of the BST class with the provided options.
      */
-    // @ts-ignore
     createTree(options) {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
@@ -9387,6 +9382,20 @@ var dataStructureTyped = (() => {
         isReverse: this._isReverse
       }, options));
     }
+    /**
+     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
+     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * element.
+     * @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.
+     * @returns either a NODE object or undefined.
+     */
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+      const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+      if (node === null) return [void 0, void 0];
+      return [node, value != null ? value : entryValue];
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -9460,7 +9469,7 @@ var dataStructureTyped = (() => {
             this._size++;
             return true;
           }
-          current = current.left;
+          if (current.left !== null) current = current.left;
         } else {
           if (current.right === void 0) {
             current.right = newNode;
@@ -9468,7 +9477,7 @@ var dataStructureTyped = (() => {
             this._size++;
             return true;
           }
-          current = current.right;
+          if (current.right !== null) current = current.right;
         }
       }
       return false;
@@ -9567,18 +9576,6 @@ var dataStructureTyped = (() => {
       }
       return inserted;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `merge` function overrides the base class method by adding elements from another
-     * binary search tree.
-     * @param anotherTree - `anotherTree` is an instance of a Binary Search Tree (BST) with key type `K`,
-     * value type `V`, return type `R`, node type `NODE`, and tree type `TREE`.
-     */
-    merge(anotherTree) {
-      this.addMany(anotherTree, [], false);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
@@ -9925,7 +9922,7 @@ var dataStructureTyped = (() => {
         while (stack.length > 0 || node) {
           if (node) {
             stack.push(node);
-            node = node.left;
+            if (node.left !== null) node = node.left;
           } else {
             node = stack[stack.length - 1];
             if (!node.right || last === node.right) {
@@ -9944,28 +9941,20 @@ var dataStructureTyped = (() => {
       }
       return balanced;
     }
-    // @ts-ignore
-    map(callback, options, thisArg) {
-      const newTree = new _BST([], options);
-      let index = 0;
-      for (const [key, value] of this) {
-        newTree.add(callback.call(thisArg, key, value, index++, this));
-      }
-      return newTree;
+    /**
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
+     */
+    get comparator() {
+      return this._comparator;
     }
     /**
-     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
-     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
-     * element.
-     * @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.
-     * @returns either a NODE object or undefined.
+     * This function returns the value of the `_specifyComparable` property.
+     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
+     * `_specifyComparable` property.
      */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-      const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
-      if (node === null) return [void 0, void 0];
-      return [node, value != null ? value : entryValue];
+    get specifyComparable() {
+      return this._specifyComparable;
     }
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
@@ -9981,6 +9970,14 @@ var dataStructureTyped = (() => {
     _compare(a, b) {
       return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
     }
+    map(callback, options, thisArg) {
+      const newTree = new _BST([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
+    }
   };
 
   // src/data-structures/binary-tree/binary-indexed-tree.ts
@@ -10558,23 +10555,6 @@ var dataStructureTyped = (() => {
      */
     constructor(key, value) {
       super(key, value);
-      __publicField(this, "_height");
-      this._height = 0;
-    }
-    /**
-     * The function returns the value of the height property.
-     * @returns The height of the object.
-     */
-    get height() {
-      return this._height;
-    }
-    /**
-     * The above function sets the value of the height property.
-     * @param {number} value - The value parameter is a number that represents the new height value to be
-     * set.
-     */
-    set height(value) {
-      this._height = value;
     }
   };
   var AVLTree = class _AVLTree extends BST {
@@ -10606,16 +10586,12 @@ var dataStructureTyped = (() => {
       return new AVLTreeNode(key, this._isMapMode ? void 0 : value);
     }
     /**
-     * The function `createTree` in TypeScript overrides the default AVLTree creation with the provided
-     * options.
-     * @param [options] - The `options` parameter in the `createTree` function is an object that contains
-     * configuration options for creating an AVL tree. These options can include properties such as
-     * `iterationType`, `isMapMode`, `specifyComparable`, `toEntryFn`, and `isReverse`. The function
-     * creates a
-     * @returns An AVLTree object is being returned with the specified options and properties inherited
-     * from the current object.
-     */
-    // @ts-ignore
+     * The function creates a new AVL tree with the specified options and returns it.
+     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
+     * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
+     * being created.
+     * @returns a new AVLTree object.
+     */
     createTree(options) {
       return new _AVLTree([], __spreadValues({
         iterationType: this.iterationType,
@@ -10676,7 +10652,6 @@ var dataStructureTyped = (() => {
       }
       return deletedResults;
     }
-    // @ts-ignore
     map(callback, options, thisArg) {
       const newTree = new _AVLTree([], options);
       let index = 0;
@@ -10760,7 +10735,7 @@ var dataStructureTyped = (() => {
     _balanceLL(A) {
       const parentOfA = A.parent;
       const B = A.left;
-      A.parent = B;
+      if (B !== null) A.parent = B;
       if (B && B.right) {
         B.right.parent = A;
       }
@@ -10795,11 +10770,11 @@ var dataStructureTyped = (() => {
       if (B) {
         C = B.right;
       }
-      if (A) A.parent = C;
-      if (B) B.parent = C;
+      if (A && C !== null) A.parent = C;
+      if (B && C !== null) B.parent = C;
       if (C) {
         if (C.left) {
-          C.left.parent = B;
+          if (B !== null) C.left.parent = B;
         }
         if (C.right) {
           C.right.parent = A;
@@ -10837,7 +10812,7 @@ var dataStructureTyped = (() => {
     _balanceRR(A) {
       const parentOfA = A.parent;
       const B = A.right;
-      A.parent = B;
+      if (B !== null) A.parent = B;
       if (B) {
         if (B.left) {
           B.left.parent = A;
@@ -10876,14 +10851,14 @@ var dataStructureTyped = (() => {
       if (B) {
         C = B.left;
       }
-      A.parent = C;
-      if (B) B.parent = C;
+      if (C !== null) A.parent = C;
+      if (B && C !== null) B.parent = C;
       if (C) {
         if (C.left) {
           C.left.parent = A;
         }
         if (C.right) {
-          C.right.parent = B;
+          if (B !== null) C.right.parent = B;
         }
         C.parent = parentOfA;
       }
@@ -10978,30 +10953,15 @@ var dataStructureTyped = (() => {
      */
     constructor(key, value, color = "BLACK") {
       super(key, value);
-      __publicField(this, "_color");
       this._color = color;
     }
-    /**
-     * The function returns the color value of a variable.
-     * @returns The color value stored in the private variable `_color`.
-     */
-    get color() {
-      return this._color;
-    }
-    /**
-     * The function sets the color property to the specified value.
-     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
-     */
-    set color(value) {
-      this._color = value;
-    }
   };
   var RedBlackTree = class _RedBlackTree extends BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
-     * initialize the RedBlackTree with the provided elements.
+     * initialize the RBTree with the provided elements.
      * @param [options] - The `options` parameter is an optional object that can be passed to the
      * constructor. It is of type `RedBlackTreeOptions<K, V, R>`. This object can contain various options for
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
@@ -11040,15 +11000,11 @@ var dataStructureTyped = (() => {
       return new RedBlackTreeNode(key, this._isMapMode ? void 0 : value, color);
     }
     /**
-     * The function `createTree` overrides the default implementation to create a Red-Black Tree with
-     * specified options in TypeScript.
-     * @param [options] - The `options` parameter in the `createTree` method is of type `RedBlackTreeOptions<K,
-     * V, R>`, which is a generic type with three type parameters `K`, `V`, and `R`. This parameter
-     * allows you to pass additional configuration options when creating a new Red-
-     * @returns A new instance of a RedBlackTree with the specified options and properties from the
-     * current object is being returned.
+     * The function creates a new Red-Black Tree with the specified options.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the Red-Black Tree. It has the following properties:
+     * @returns a new instance of a RedBlackTree object.
      */
-    // @ts-ignore
     createTree(options) {
       return new _RedBlackTree([], __spreadValues({
         iterationType: this.iterationType,
@@ -11142,8 +11098,10 @@ var dataStructureTyped = (() => {
       let originalColor = nodeToDelete.color;
       let replacementNode;
       if (!this.isRealNode(nodeToDelete.left)) {
-        replacementNode = nodeToDelete.right;
-        this._transplant(nodeToDelete, nodeToDelete.right);
+        if (nodeToDelete.right !== null) {
+          replacementNode = nodeToDelete.right;
+          this._transplant(nodeToDelete, nodeToDelete.right);
+        }
       } else if (!this.isRealNode(nodeToDelete.right)) {
         replacementNode = nodeToDelete.left;
         this._transplant(nodeToDelete, nodeToDelete.left);
@@ -11151,14 +11109,16 @@ var dataStructureTyped = (() => {
         const successor = this.getLeftMost((node) => node, nodeToDelete.right);
         if (successor) {
           originalColor = successor.color;
-          replacementNode = successor.right;
+          if (successor.right !== null) replacementNode = successor.right;
           if (successor.parent === nodeToDelete) {
             if (this.isRealNode(replacementNode)) {
               replacementNode.parent = successor;
             }
           } else {
-            this._transplant(successor, successor.right);
-            successor.right = nodeToDelete.right;
+            if (successor.right !== null) {
+              this._transplant(successor, successor.right);
+              successor.right = nodeToDelete.right;
+            }
             if (this.isRealNode(successor.right)) {
               successor.right.parent = successor;
             }
@@ -11179,35 +11139,6 @@ var dataStructureTyped = (() => {
       results.push({ deleted: nodeToDelete, needBalanced: void 0 });
       return results;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
-     * applying a callback to each entry in the original tree.
-     * @param callback - A function that will be called for each entry in the tree, with parameters
-     * representing the key, value, index, and the tree itself. It should return an entry for the new
-     * tree.
-     * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
-     * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
-     * Tree that will be created during the mapping process. These options could include things like
-     * custom comparators
-     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-     * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) for the callback function. This can be useful when you want to access properties
-     * or
-     * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
-     * provided callback function.
-     */
-    // @ts-ignore
-    map(callback, options, thisArg) {
-      const newTree = new _RedBlackTree([], options);
-      let index = 0;
-      for (const [key, value] of this) {
-        newTree.add(callback.call(thisArg, key, value, index++, this));
-      }
-      return newTree;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -11310,7 +11241,7 @@ var dataStructureTyped = (() => {
      * structure. It can either be a valid node or `undefined`.
      */
     _insertFixup(z) {
-      var _a, _b, _c, _d;
+      var _a, _b, _c, _d, _e;
       while (((_a = z == null ? void 0 : z.parent) == null ? void 0 : _a.color) === "RED") {
         if (z.parent === ((_b = z.parent.parent) == null ? void 0 : _b.left)) {
           const y = z.parent.parent.right;
@@ -11331,7 +11262,7 @@ var dataStructureTyped = (() => {
             }
           }
         } else {
-          const y = (_d = (_c = z == null ? void 0 : z.parent) == null ? void 0 : _c.parent) == null ? void 0 : _d.left;
+          const y = (_e = (_d = (_c = z == null ? void 0 : z.parent) == null ? void 0 : _c.parent) == null ? void 0 : _d.left) != null ? _e : void 0;
           if ((y == null ? void 0 : y.color) === "RED") {
             z.parent.color = "BLACK";
             y.color = "BLACK";
@@ -11476,6 +11407,34 @@ var dataStructureTyped = (() => {
       x.right = y;
       y.parent = x;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
+     * applying a callback to each entry in the original tree.
+     * @param callback - A function that will be called for each entry in the tree, with parameters
+     * representing the key, value, index, and the tree itself. It should return an entry for the new
+     * tree.
+     * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
+     * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
+     * Tree that will be created during the mapping process. These options could include things like
+     * custom comparators
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function. This can be useful when you want to access properties
+     * or
+     * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
+     * provided callback function.
+     */
+    map(callback, options, thisArg) {
+      const newTree = new _RedBlackTree([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
+    }
   };
 
   // src/data-structures/binary-tree/avl-tree-multi-map.ts
@@ -11492,24 +11451,8 @@ var dataStructureTyped = (() => {
      */
     constructor(key, value, count = 1) {
       super(key, value);
-      __publicField(this, "_count", 1);
       this.count = count;
     }
-    /**
-     * The function returns the value of the protected 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 AVLTreeMultiMap = class _AVLTreeMultiMap extends AVLTree {
     /**
@@ -11567,7 +11510,6 @@ var dataStructureTyped = (() => {
      * @returns a new instance of the AVLTreeMultiMap class, with the specified options, as a TREE
      * object.
      */
-    // @ts-ignore
     createTree(options) {
       return new _AVLTreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
@@ -11647,7 +11589,7 @@ var dataStructureTyped = (() => {
       } else {
         if (!curr.left) {
           if (!parent) {
-            if (curr.right !== void 0) this._setRoot(curr.right);
+            if (curr.right !== void 0 && curr.right !== null) this._setRoot(curr.right);
           } else {
             const { familyPosition: fp } = curr;
             if (fp === "LEFT" || fp === "ROOT_LEFT") {
@@ -11746,7 +11688,6 @@ var dataStructureTyped = (() => {
      * 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.
      */
-    // @ts-ignore
     clone() {
       const cloned = this.createTree();
       if (this._isMapMode) this.bfs((node) => cloned.add(node.key, void 0, node.count));
@@ -11772,7 +11713,6 @@ var dataStructureTyped = (() => {
      * `callback` function along with the index and the original tree itself. The transformed entries are
      * then added to the new `AVLTreeMultiMap` instance, which is returned at the end.
      */
-    // @ts-ignore
     map(callback, options, thisArg) {
       const newTree = new _AVLTreeMultiMap([], options);
       let index = 0;
@@ -11877,24 +11817,8 @@ var dataStructureTyped = (() => {
      */
     constructor(key, value, count = 1, color = "BLACK") {
       super(key, value, color);
-      __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 {
     /**
@@ -11956,7 +11880,6 @@ var dataStructureTyped = (() => {
      * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
-    // @ts-ignore
     createTree(options) {
       return new _TreeMultiMap([], __spreadValues({
         iterationType: this.iterationType,
@@ -11965,6 +11888,35 @@ var dataStructureTyped = (() => {
         toEntryFn: this._toEntryFn
       }, options));
     }
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
+     * node based on the input.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {V} [value] - The `value` parameter is an optional value that represents the value
+     * associated with the key in the node. It is used when creating a new node or updating the value of
+     * an existing node.
+     * @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 data structure. If not provided, it defaults to 1.
+     * @returns either a NODE object or undefined.
+     */
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
+      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
+      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+      if (this.isEntry(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = keyNodeEntryOrRaw;
+        if (key === void 0 || key === null) return [void 0, void 0];
+        const finalValue = value != null ? value : entryValue;
+        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
+      }
+      if (this.isRaw(keyNodeEntryOrRaw)) {
+        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+        const finalValue = value != null ? value : entryValue;
+        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
+      }
+      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, "BLACK", count), value];
+      return [void 0, void 0];
+    }
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
      * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
@@ -12029,10 +11981,12 @@ var dataStructureTyped = (() => {
       let originalColor = nodeToDelete.color;
       let replacementNode;
       if (!this.isRealNode(nodeToDelete.left)) {
-        replacementNode = nodeToDelete.right;
+        if (nodeToDelete.right !== null) replacementNode = nodeToDelete.right;
         if (ignoreCount || nodeToDelete.count <= 1) {
-          this._transplant(nodeToDelete, nodeToDelete.right);
-          this._count -= nodeToDelete.count;
+          if (nodeToDelete.right !== null) {
+            this._transplant(nodeToDelete, nodeToDelete.right);
+            this._count -= nodeToDelete.count;
+          }
         } else {
           nodeToDelete.count--;
           this._count--;
@@ -12054,15 +12008,17 @@ var dataStructureTyped = (() => {
         const successor = this.getLeftMost((node) => node, nodeToDelete.right);
         if (successor) {
           originalColor = successor.color;
-          replacementNode = successor.right;
+          if (successor.right !== null) replacementNode = successor.right;
           if (successor.parent === nodeToDelete) {
             if (this.isRealNode(replacementNode)) {
               replacementNode.parent = successor;
             }
           } else {
             if (ignoreCount || nodeToDelete.count <= 1) {
-              this._transplant(successor, successor.right);
-              this._count -= nodeToDelete.count;
+              if (successor.right !== null) {
+                this._transplant(successor, successor.right);
+                this._count -= nodeToDelete.count;
+              }
             } else {
               nodeToDelete.count--;
               this._count--;
@@ -12163,66 +12119,12 @@ var dataStructureTyped = (() => {
      * 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.
      */
-    // @ts-ignore
     clone() {
       const cloned = this.createTree();
       this.bfs((node) => cloned.add(node.key, void 0, node.count));
       if (this._isMapMode) cloned._store = this._store;
       return cloned;
     }
-    /**
-     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
-     * modified entries based on a provided callback.
-     * @param callback - The `callback` parameter is a function that will be called for each entry in the
-     * map. It takes four arguments:
-     * @param [options] - The `options` parameter in the `override map` function is of type
-     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
-     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
-     * include things like
-     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-     * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) for the callback function when it is called within the `map` function. This
-     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
-     * by the provided callback function.
-     */
-    // @ts-ignore
-    map(callback, options, thisArg) {
-      const newTree = new _TreeMultiMap([], options);
-      let index = 0;
-      for (const [key, value] of this) {
-        newTree.add(callback.call(thisArg, key, value, index++, this));
-      }
-      return newTree;
-    }
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
-     * node based on the input.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that represents the value
-     * associated with the key in the node. It is used when creating a new node or updating the value of
-     * an existing node.
-     * @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 data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
-     */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
-      if (keyNodeEntryOrRaw === void 0 || keyNodeEntryOrRaw === null) return [void 0, void 0];
-      if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-      if (this.isEntry(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = keyNodeEntryOrRaw;
-        if (key === void 0 || key === null) return [void 0, void 0];
-        const finalValue = value != null ? value : entryValue;
-        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
-      }
-      if (this.isRaw(keyNodeEntryOrRaw)) {
-        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-        const finalValue = value != null ? value : entryValue;
-        if (this.isKey(key)) return [this.createNode(key, finalValue, "BLACK", count), finalValue];
-      }
-      if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, "BLACK", count), value];
-      return [void 0, void 0];
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -12273,6 +12175,29 @@ var dataStructureTyped = (() => {
       newNode.count = oldNode.count + newNode.count;
       return super._replaceNode(oldNode, newNode);
     }
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
+     * modified entries based on a provided callback.
+     * @param callback - The `callback` parameter is a function that will be called for each entry in the
+     * map. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
+     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
+     * include things like
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function when it is called within the `map` function. This
+     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
+     * by the provided callback function.
+     */
+    map(callback, options, thisArg) {
+      const newTree = new _TreeMultiMap([], options);
+      let index = 0;
+      for (const [key, value] of this) {
+        newTree.add(callback.call(thisArg, key, value, index++, this));
+      }
+      return newTree;
+    }
   };
 
   // src/data-structures/priority-queue/priority-queue.ts