data-structure-typed 1.49.5 → 1.49.7

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

@@ -124,8 +124,6 @@ var dataStructureTyped = (() => {
     FibonacciHeap: () => FibonacciHeap,
     FibonacciHeapNode: () => FibonacciHeapNode,
     HashMap: () => HashMap,
-    HashTable: () => HashTable,
-    HashTableNode: () => HashTableNode,
     Heap: () => Heap,
     IterableElementBase: () => IterableElementBase,
     IterableEntryBase: () => IterableEntryBase,
@@ -176,273 +174,6 @@ var dataStructureTyped = (() => {
     uuidV4: () => uuidV4
   });
 
-  // src/data-structures/hash/hash-table.ts
-  var HashTableNode = class {
-    constructor(key, value) {
-      __publicField(this, "key");
-      __publicField(this, "value");
-      __publicField(this, "next");
-      this.key = key;
-      this.value = value;
-      this.next = void 0;
-    }
-  };
-  var _HashTable = class _HashTable {
-    constructor(capacity = _HashTable.DEFAULT_CAPACITY, hashFn) {
-      __publicField(this, "_capacity");
-      __publicField(this, "_size");
-      __publicField(this, "_buckets");
-      __publicField(this, "_hashFn");
-      this._hashFn = hashFn || this._defaultHashFn;
-      this._capacity = Math.max(capacity, _HashTable.DEFAULT_CAPACITY);
-      this._size = 0;
-      this._buckets = new Array(this._capacity).fill(void 0);
-    }
-    get capacity() {
-      return this._capacity;
-    }
-    get size() {
-      return this._size;
-    }
-    get buckets() {
-      return this._buckets;
-    }
-    get hashFn() {
-      return this._hashFn;
-    }
-    /**
-     * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
-     * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
-     * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} value - The parameter `value` represents the value that you want to associate with the given key in the hash
-     * table.
-     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
-     * value.
-     */
-    set(key, value) {
-      const index = this._hash(key);
-      const newNode = new HashTableNode(key, value);
-      if (!this._buckets[index]) {
-        this._buckets[index] = newNode;
-      } else {
-        let currentNode = this._buckets[index];
-        while (currentNode) {
-          if (currentNode.key === key) {
-            currentNode.value = value;
-            return;
-          }
-          if (!currentNode.next) {
-            break;
-          }
-          currentNode = currentNode.next;
-        }
-        currentNode.next = newNode;
-      }
-      this._size++;
-      if (this._size / this._capacity >= _HashTable.LOAD_FACTOR) {
-        this._expand();
-      }
-    }
-    /**
-     * The `get` function retrieves the value associated with a given key from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
-     * structure.
-     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
-     * not found, it returns `undefined`.
-     */
-    get(key) {
-      const index = this._hash(key);
-      let currentNode = this._buckets[index];
-      while (currentNode) {
-        if (currentNode.key === key) {
-          return currentNode.value;
-        }
-        currentNode = currentNode.next;
-      }
-      return void 0;
-    }
-    /**
-     * The delete function removes a key-value pair from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
-     * table.
-     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
-     * any value.
-     */
-    delete(key) {
-      const index = this._hash(key);
-      let currentNode = this._buckets[index];
-      let prevNode = void 0;
-      while (currentNode) {
-        if (currentNode.key === key) {
-          if (prevNode) {
-            prevNode.next = currentNode.next;
-          } else {
-            this._buckets[index] = currentNode.next;
-          }
-          this._size--;
-          currentNode.next = void 0;
-          return;
-        }
-        prevNode = currentNode;
-        currentNode = currentNode.next;
-      }
-    }
-    *[Symbol.iterator]() {
-      for (const bucket of this._buckets) {
-        let currentNode = bucket;
-        while (currentNode) {
-          yield [currentNode.key, currentNode.value];
-          currentNode = currentNode.next;
-        }
-      }
-    }
-    forEach(callback) {
-      let index = 0;
-      for (const entry of this) {
-        callback(entry, index, this);
-        index++;
-      }
-    }
-    filter(predicate) {
-      const newTable = new _HashTable();
-      let index = 0;
-      for (const [key, value] of this) {
-        if (predicate([key, value], index, this)) {
-          newTable.set(key, value);
-        }
-        index++;
-      }
-      return newTable;
-    }
-    map(callback) {
-      const newTable = new _HashTable();
-      let index = 0;
-      for (const [key, value] of this) {
-        newTable.set(key, callback([key, value], index, this));
-        index++;
-      }
-      return newTable;
-    }
-    reduce(callback, initialValue) {
-      let accumulator = initialValue;
-      let index = 0;
-      for (const entry of this) {
-        accumulator = callback(accumulator, entry, index, this);
-        index++;
-      }
-      return accumulator;
-    }
-    /**
-     * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
-     * capacity of the data structure.
-     * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
-     * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
-     * function is used to
-     * @returns the hash value of the key modulo the capacity of the data structure.
-     */
-    _defaultHashFn(key) {
-      const hashValue = typeof key === "string" ? this._murmurStringHashFn(key) : this._objectHash(key);
-      return hashValue % this._capacity;
-    }
-    /**
-     * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
-     * string hash function.
-     * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
-     * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
-     * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
-     */
-    _multiplicativeStringHashFn(key) {
-      const keyString = String(key);
-      let hash = 0;
-      for (let i = 0; i < keyString.length; i++) {
-        const charCode = keyString.charCodeAt(i);
-        const A = 0.618033988749895;
-        const M = 1 << 30;
-        hash = (hash * A + charCode) % M;
-      }
-      return Math.abs(hash);
-    }
-    /**
-     * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
-     * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
-     * type, but it will be converted to a string using the `String()` function before calculating the hash.
-     * @returns a number, which is the hash value calculated for the given key.
-     */
-    _murmurStringHashFn(key) {
-      const keyString = String(key);
-      const seed = 0;
-      let hash = seed;
-      for (let i = 0; i < keyString.length; i++) {
-        const char = keyString.charCodeAt(i);
-        hash = (hash ^ char) * 1540483477;
-        hash = (hash ^ hash >>> 15) * 668265261;
-        hash = hash ^ hash >>> 15;
-      }
-      return Math.abs(hash);
-    }
-    /**
-     * The _hash function takes a key and returns a number.
-     * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
-     * @returns The hash function is returning a number.
-     */
-    _hash(key) {
-      return this.hashFn(key);
-    }
-    /**
-     * The function calculates a hash value for a given string using the djb2 algorithm.
-     * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
-     * which we want to calculate the hash value.
-     * @returns a number, which is the hash value of the input string.
-     */
-    _stringHash(key) {
-      let hash = 0;
-      for (let i = 0; i < key.length; i++) {
-        hash = hash * 31 + key.charCodeAt(i) & 4294967295;
-      }
-      return hash;
-    }
-    /**
-     * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
-     * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
-     * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
-     * the key, which can be used for
-     * @returns a number, which is the hash value of the key.
-     */
-    _objectHash(key) {
-      return this._stringHash(JSON.stringify(key));
-    }
-    /**
-     * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
-     * capacity and rehashing all the existing key-value pairs into the new buckets.
-     */
-    _expand() {
-      const newCapacity = this._capacity * 2;
-      const newBuckets = new Array(newCapacity).fill(void 0);
-      for (const bucket of this._buckets) {
-        let currentNode = bucket;
-        while (currentNode) {
-          const newIndex = this._hash(currentNode.key);
-          const newNode = new HashTableNode(currentNode.key, currentNode.value);
-          if (!newBuckets[newIndex]) {
-            newBuckets[newIndex] = newNode;
-          } else {
-            let currentNewNode = newBuckets[newIndex];
-            while (currentNewNode.next) {
-              currentNewNode = currentNewNode.next;
-            }
-            currentNewNode.next = newNode;
-          }
-          currentNode = currentNode.next;
-        }
-      }
-      this._buckets = newBuckets;
-      this._capacity = newCapacity;
-    }
-  };
-  __publicField(_HashTable, "DEFAULT_CAPACITY", 16);
-  __publicField(_HashTable, "LOAD_FACTOR", 0.75);
-  var HashTable = _HashTable;
-
   // src/data-structures/base/iterable-base.ts
   var IterableEntryBase = class {
     /**
@@ -854,14 +585,14 @@ var dataStructureTyped = (() => {
   // src/data-structures/hash/hash-map.ts
   var HashMap = class _HashMap extends IterableEntryBase {
     /**
-     * The constructor function initializes a new instance of a class with optional elements and options.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * The constructor function initializes a new instance of a class with optional entries and options.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
      * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
      * key-value pairs.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the constructor. In this case, it has one property:
      */
-    constructor(elements = [], options) {
+    constructor(entries = [], options) {
       super();
       __publicField(this, "_store", {});
       __publicField(this, "_objMap", /* @__PURE__ */ new Map());
@@ -873,8 +604,8 @@ var dataStructureTyped = (() => {
           this._hashFn = hashFn;
         }
       }
-      if (elements) {
-        this.setMany(elements);
+      if (entries) {
+        this.setMany(entries);
       }
     }
     get size() {
@@ -914,12 +645,12 @@ var dataStructureTyped = (() => {
     }
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two elements: the key and the value.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two entries: the key and the value.
      */
-    setMany(elements) {
+    setMany(entries) {
       const results = [];
-      for (const [key, value] of elements)
+      for (const [key, value] of entries)
         results.push(this.set(key, value));
       return results;
     }
@@ -1033,9 +764,6 @@ var dataStructureTyped = (() => {
       }
       return filteredMap;
     }
-    print() {
-      console.log([...this.entries()]);
-    }
     put(key, value) {
       return this.set(key, value);
     }
@@ -1071,26 +799,31 @@ var dataStructureTyped = (() => {
     }
   };
   var LinkedHashMap = class _LinkedHashMap extends IterableEntryBase {
-    constructor(elements, options = {
-      hashFn: (key) => String(key),
-      objHashFn: (key) => key
-    }) {
+    constructor(entries, options) {
       super();
       __publicField(this, "_noObjMap", {});
       __publicField(this, "_objMap", /* @__PURE__ */ new WeakMap());
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_sentinel");
-      __publicField(this, "_hashFn");
-      __publicField(this, "_objHashFn");
       __publicField(this, "_size", 0);
+      /**
+       * Time Complexity: O(n)
+       * Space Complexity: O(n)
+       */
+      __publicField(this, "_hashFn", (key) => String(key));
+      __publicField(this, "_objHashFn", (key) => key);
       this._sentinel = {};
       this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-      const { hashFn, objHashFn } = options;
-      this._hashFn = hashFn;
-      this._objHashFn = objHashFn;
-      if (elements) {
-        for (const el of elements) {
+      if (options) {
+        const { hashFn, objHashFn } = options;
+        if (hashFn)
+          this._hashFn = hashFn;
+        if (objHashFn)
+          this._objHashFn = objHashFn;
+      }
+      if (entries) {
+        for (const el of entries) {
           this.set(el[0], el[1]);
         }
       }
@@ -1314,7 +1047,7 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function clears all the elements in a data structure and resets its properties.
+     * The `clear` function clears all the entries in a data structure and resets its properties.
      */
     clear() {
       this._noObjMap = {};
@@ -1329,10 +1062,6 @@ var dataStructureTyped = (() => {
       }
       return cloned;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -1359,10 +1088,6 @@ var dataStructureTyped = (() => {
       }
       return filteredMap;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -1390,11 +1115,15 @@ var dataStructureTyped = (() => {
       }
       return mappedMap;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     put(key, value) {
       return this.set(key, value);
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
+     * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
@@ -1449,14 +1178,11 @@ var dataStructureTyped = (() => {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor(elements) {
+    constructor(elements = []) {
       super();
       __publicField(this, "_head");
       __publicField(this, "_tail");
-      __publicField(this, "_size");
-      this._head = void 0;
-      this._tail = void 0;
-      this._size = 0;
+      __publicField(this, "_size", 0);
       if (elements) {
         for (const el of elements)
           this.push(el);
@@ -2126,7 +1852,7 @@ var dataStructureTyped = (() => {
     /**
      * The constructor initializes the linked list with an empty head, tail, and size.
      */
-    constructor(elements) {
+    constructor(elements = []) {
       super();
       __publicField(this, "_head");
       __publicField(this, "_tail");
@@ -2852,22 +2578,22 @@ var dataStructureTyped = (() => {
     }
   };
   var SkipList = class {
-    /**
-     * The constructor initializes a SkipList with a specified maximum level and probability.
-     * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
-     * the maximum number of levels that can be created in the skip list.
-     * @param [probability=0.5] - The probability parameter represents the probability of a node being promoted to a higher
-     * level in the skip list. It is used to determine the height of each node in the skip list.
-     */
-    constructor(maxLevel = 16, probability = 0.5) {
-      __publicField(this, "_head");
-      __publicField(this, "_level");
-      __publicField(this, "_maxLevel");
-      __publicField(this, "_probability");
-      this._head = new SkipListNode(void 0, void 0, maxLevel);
-      this._level = 0;
-      this._maxLevel = maxLevel;
-      this._probability = probability;
+    constructor(elements = [], options) {
+      __publicField(this, "_head", new SkipListNode(void 0, void 0, this.maxLevel));
+      __publicField(this, "_level", 0);
+      __publicField(this, "_maxLevel", 16);
+      __publicField(this, "_probability", 0.5);
+      if (options) {
+        const { maxLevel, probability } = options;
+        if (typeof maxLevel === "number")
+          this._maxLevel = maxLevel;
+        if (typeof probability === "number")
+          this._probability = probability;
+      }
+      if (elements) {
+        for (const [key, value] of elements)
+          this.add(key, value);
+      }
     }
     get head() {
       return this._head;
@@ -3096,14 +2822,12 @@ var dataStructureTyped = (() => {
      * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
      * is provided and is an array, it is assigned to the `_elements
      */
-    constructor(elements) {
+    constructor(elements = []) {
       super();
-      __publicField(this, "_elements");
-      this._elements = [];
+      __publicField(this, "_elements", []);
       if (elements) {
-        for (const el of elements) {
+        for (const el of elements)
           this.push(el);
-        }
       }
     }
     get elements() {
@@ -3295,18 +3019,20 @@ var dataStructureTyped = (() => {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
      * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
-     * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
+     * will be used to initialize the `_elements` property of the class. If not provided, the `_elements` property will be
      * initialized as an empty array.
      */
-    constructor(elements) {
+    constructor(elements = []) {
       super();
-      __publicField(this, "_nodes");
-      __publicField(this, "_offset");
-      this._nodes = elements || [];
-      this._offset = 0;
+      __publicField(this, "_elements", []);
+      __publicField(this, "_offset", 0);
+      if (elements) {
+        for (const el of elements)
+          this.push(el);
+      }
     }
-    get nodes() {
-      return this._nodes;
+    get elements() {
+      return this._elements;
     }
     get offset() {
       return this._offset;
@@ -3316,18 +3042,18 @@ var dataStructureTyped = (() => {
      * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
      */
     get size() {
-      return this.nodes.length - this.offset;
+      return this.elements.length - this.offset;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` 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`.
      */
     get first() {
-      return this.size > 0 ? this.nodes[this.offset] : void 0;
+      return this.size > 0 ? this.elements[this.offset] : void 0;
     }
     /**
      * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
@@ -3338,11 +3064,11 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1) - no additional space is used.
      *
      * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * @returns The method `get last()` returns the last element of the `_elements` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
     get last() {
-      return this.size > 0 ? this.nodes[this.nodes.length - 1] : void 0;
+      return this.size > 0 ? this.elements[this.elements.length - 1] : void 0;
     }
     /**
      * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
@@ -3372,7 +3098,7 @@ var dataStructureTyped = (() => {
      * @returns The `add` method is returning a `Queue<E>` object.
      */
     push(element) {
-      this.nodes.push(element);
+      this.elements.push(element);
       return true;
     }
     /**
@@ -3392,9 +3118,9 @@ var dataStructureTyped = (() => {
         return void 0;
       const first = this.first;
       this._offset += 1;
-      if (this.offset * 2 < this.nodes.length)
+      if (this.offset * 2 < this.elements.length)
         return first;
-      this._nodes = this.nodes.slice(this.offset);
+      this._elements = this.elements.slice(this.offset);
       this._offset = 0;
       return first;
     }
@@ -3406,8 +3132,8 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * 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() {
@@ -3422,7 +3148,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1) - no additional space is used.
      *
      * 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 `_nodes` array if the array is not empty. If the
+     * @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() {
@@ -3467,7 +3193,7 @@ var dataStructureTyped = (() => {
      * @param index
      */
     getAt(index) {
-      return this.nodes[index];
+      return this.elements[index];
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
@@ -3491,17 +3217,17 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
      * Space Complexity: O(n) - where n is the number of elements in the queue.
      *
-     * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
+     * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
      * @returns An array of type E is being returned.
      */
     toArray() {
-      return this.nodes.slice(this.offset);
+      return this.elements.slice(this.offset);
     }
     /**
-     * The clear function resets the nodes array and offset to their initial values.
+     * The clear function resets the elements array and offset to their initial values.
      */
     clear() {
-      this._nodes = [];
+      this._elements = [];
       this._offset = 0;
     }
     /**
@@ -3516,7 +3242,7 @@ var dataStructureTyped = (() => {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone() {
-      return new _Queue(this.nodes.slice(this.offset));
+      return new _Queue(this.elements.slice(this.offset));
     }
     /**
      * Time Complexity: O(n)
@@ -3581,7 +3307,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n)
      */
     *_getIterator() {
-      for (const item of this.nodes) {
+      for (const item of this.elements) {
         yield item;
       }
     }
@@ -3620,25 +3346,21 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/queue/deque.ts
   var Deque = class _Deque extends IterableElementBase {
-    /**
-     * The constructor initializes a data structure with a specified bucket size and populates it with
-     * elements from an iterable.
-     * @param elements - The `elements` parameter is an iterable object (such as an array or a Set) that
-     * contains the initial elements to be stored in the data structure. It can also be an object with a
-     * `length` property or a `size` property, which represents the number of elements in the iterable.
-     * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
-     * stored in each bucket. It determines the size of each bucket in the data structure.
-     */
-    constructor(elements = [], bucketSize = 1 << 12) {
+    constructor(elements = [], options) {
       super();
       __publicField(this, "_bucketFirst", 0);
       __publicField(this, "_firstInBucket", 0);
       __publicField(this, "_bucketLast", 0);
       __publicField(this, "_lastInBucket", 0);
       __publicField(this, "_bucketCount", 0);
-      __publicField(this, "_bucketSize");
+      __publicField(this, "_bucketSize", 1 << 12);
       __publicField(this, "_buckets", []);
       __publicField(this, "_size", 0);
+      if (options) {
+        const { bucketSize } = options;
+        if (typeof bucketSize === "number")
+          this._bucketSize = bucketSize;
+      }
       let _size;
       if ("length" in elements) {
         if (elements.length instanceof Function)
@@ -3651,7 +3373,6 @@ var dataStructureTyped = (() => {
         else
           _size = elements.size;
       }
-      this._bucketSize = bucketSize;
       this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
       for (let i = 0; i < this._bucketCount; ++i) {
         this._buckets.push(new Array(this._bucketSize));
@@ -4210,7 +3931,7 @@ var dataStructureTyped = (() => {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-      const newDeque = new _Deque([], this._bucketSize);
+      const newDeque = new _Deque([], { bucketSize: this._bucketSize });
       let index = 0;
       for (const el of this) {
         if (predicate.call(thisArg, el, index, this)) {
@@ -4238,7 +3959,7 @@ var dataStructureTyped = (() => {
      * @returns a new Deque object with the mapped values.
      */
     map(callback, thisArg) {
-      const newDeque = new _Deque([], this._bucketSize);
+      const newDeque = new _Deque([], { bucketSize: this._bucketSize });
       let index = 0;
       for (const el of this) {
         newDeque.push(callback.call(thisArg, el, index, this));
@@ -4374,23 +4095,20 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/heap/heap.ts
   var Heap = class _Heap extends IterableElementBase {
-    constructor(elements, options) {
+    constructor(elements = [], options) {
       super();
-      __publicField(this, "options");
-      __publicField(this, "_elements", []);
-      const defaultComparator = (a, b) => {
+      __publicField(this, "_comparator", (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
         } else {
           return a - b;
         }
-      };
+      });
+      __publicField(this, "_elements", []);
       if (options) {
-        this.options = options;
-      } else {
-        this.options = {
-          comparator: defaultComparator
-        };
+        const { comparator } = options;
+        if (comparator)
+          this._comparator = comparator;
       }
       if (elements) {
         for (const el of elements) {
@@ -4398,6 +4116,9 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    get comparator() {
+      return this._comparator;
+    }
     get elements() {
       return this._elements;
     }
@@ -4602,7 +4323,7 @@ var dataStructureTyped = (() => {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-      const clonedHeap = new _Heap([], this.options);
+      const clonedHeap = new _Heap([], { comparator: this.comparator });
       clonedHeap._elements = [...this.elements];
       return clonedHeap;
     }
@@ -4728,7 +4449,7 @@ var dataStructureTyped = (() => {
       while (index > 0) {
         const parent = index - 1 >> 1;
         const parentItem = this.elements[parent];
-        if (this.options.comparator(parentItem, element) <= 0)
+        if (this.comparator(parentItem, element) <= 0)
           break;
         this.elements[index] = parentItem;
         index = parent;
@@ -4750,11 +4471,11 @@ var dataStructureTyped = (() => {
         let left = index << 1 | 1;
         const right = left + 1;
         let minItem = this.elements[left];
-        if (right < this.elements.length && this.options.comparator(minItem, this.elements[right]) > 0) {
+        if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
           left = right;
           minItem = this.elements[right];
         }
-        if (this.options.comparator(minItem, element) >= 0)
+        if (this.comparator(minItem, element) >= 0)
           break;
         this.elements[index] = minItem;
         index = left;
@@ -5113,7 +4834,7 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/heap/max-heap.ts
   var MaxHeap = class extends Heap {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -5128,7 +4849,7 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/heap/min-heap.ts
   var MinHeap = class extends Heap {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -7241,8 +6962,8 @@ var dataStructureTyped = (() => {
 
   // src/types/common.ts
   var BSTVariant = /* @__PURE__ */ ((BSTVariant2) => {
-    BSTVariant2["MIN"] = "MIN";
-    BSTVariant2["MAX"] = "MAX";
+    BSTVariant2["STANDARD"] = "STANDARD";
+    BSTVariant2["INVERSE"] = "INVERSE";
     return BSTVariant2;
   })(BSTVariant || {});
   var CP = /* @__PURE__ */ ((CP2) => {
@@ -7315,15 +7036,15 @@ var dataStructureTyped = (() => {
   };
   var BinaryTree = class _BinaryTree extends IterableEntryBase {
     /**
-     * The constructor function initializes a binary tree object with optional elements and options.
-     * @param [elements] - An optional iterable of BTNExemplar objects. These objects represent the
-     * elements to be added to the binary tree.
+     * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(elements, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
       super();
       __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
       __publicField(this, "_extractor", (key) => Number(key));
@@ -7332,16 +7053,14 @@ var dataStructureTyped = (() => {
       __publicField(this, "_defaultOneParamCallback", (node) => node ? node.key : void 0);
       if (options) {
         const { iterationType, extractor } = options;
-        if (iterationType) {
+        if (iterationType)
           this.iterationType = iterationType;
-        }
-        if (extractor) {
+        if (extractor)
           this._extractor = extractor;
-        }
       }
       this._size = 0;
-      if (elements)
-        this.addMany(elements);
+      if (keysOrNodesOrEntries)
+        this.addMany(keysOrNodesOrEntries);
     }
     get extractor() {
       return this._extractor;
@@ -7372,29 +7091,21 @@ var dataStructureTyped = (() => {
       return new _BinaryTree([], __spreadValues({ 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 `BTNExemplar<K, 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 object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
+     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the exemplar node. If no value
+     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If no value
      * is provided, it will be `undefined`.
      * @returns a value of type N (node), or null, or undefined.
      */
-    exemplarToNode(exemplar, value) {
-      if (exemplar === void 0)
+    exemplarToNode(keyOrNodeOrEntry, value) {
+      if (keyOrNodeOrEntry === void 0)
         return;
       let node;
-      if (exemplar === null) {
+      if (keyOrNodeOrEntry === null) {
         node = null;
-      } else if (this.isEntry(exemplar)) {
-        const [key, value2] = exemplar;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value2] = keyOrNodeOrEntry;
         if (key === void 0) {
           return;
         } else if (key === null) {
@@ -7402,23 +7113,104 @@ var dataStructureTyped = (() => {
         } else {
           node = this.createNode(key, value2);
         }
-      } else if (this.isNode(exemplar)) {
-        node = exemplar;
-      } else if (this.isNotNodeInstance(exemplar)) {
-        node = this.createNode(exemplar, value);
+      } else if (this.isNode(keyOrNodeOrEntry)) {
+        node = keyOrNodeOrEntry;
+      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value);
       } else {
         return;
       }
       return node;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     *
+     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
+     * key, otherwise it returns the key itself.
+     * @param {K | N | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`,
+     * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be used when searching for a node by key. It has a default value of
+     * `IterationType.ITERATIVE`.
+     * @returns either the node corresponding to the given key if it is a valid node key, or the key
+     * itself if it is not a valid node key.
+     */
+    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE" /* ITERATIVE */) {
+      let res;
+      if (this.isRealNode(keyOrNodeOrEntry)) {
+        res = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        if (keyOrNodeOrEntry[0] === null)
+          res = null;
+        else if (keyOrNodeOrEntry[0] !== void 0)
+          res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+      } else {
+        if (keyOrNodeOrEntry === null)
+          res = null;
+        else if (keyOrNodeOrEntry !== void 0)
+          res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+      }
+      return res;
+    }
+    /**
+     * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the class N.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof BinaryTreeNode;
+    }
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param kne - BTNExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,N> - A generic type representing a node in a binary tree. It has
      * two type parameters V and N, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isEntry(kne) {
-      return Array.isArray(kne) && kne.length === 2;
+    isEntry(keyOrNodeOrEntry) {
+      return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(log n)
+     */
+    /**
+     * The function checks if a given node is a real node by verifying if it is an instance of
+     * BinaryTreeNode and its key is not NaN.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isRealNode(node) {
+      return node instanceof BinaryTreeNode && String(node.key) !== "NaN";
+    }
+    /**
+     * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNIL(node) {
+      return node instanceof BinaryTreeNode && String(node.key) === "NaN";
+    }
+    /**
+     * The function checks if a given node is a real node or null.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node) {
+      return this.isRealNode(node) || node === null;
+    }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof BinaryTreeNode);
     }
     /**
      * Time Complexity O(log n) - O(n)
@@ -7437,11 +7229,11 @@ var dataStructureTyped = (() => {
     add(keyOrNodeOrEntry, value) {
       const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
-        return;
+        return false;
       if (!this.root) {
         this._root = newNode;
         this._size = 1;
-        return newNode;
+        return true;
       }
       const queue = new Queue([this.root]);
       let potentialParent;
@@ -7451,7 +7243,7 @@ var dataStructureTyped = (() => {
           continue;
         if (newNode !== null && cur.key === newNode.key) {
           this._replaceNode(cur, newNode);
-          return newNode;
+          return true;
         }
         if (potentialParent === void 0 && (cur.left === void 0 || cur.right === void 0)) {
           potentialParent = cur;
@@ -7470,9 +7262,9 @@ var dataStructureTyped = (() => {
           potentialParent.right = newNode;
         }
         this._size++;
-        return newNode;
+        return true;
       }
-      return void 0;
+      return false;
     }
     /**
      * Time Complexity: O(k log n) - O(k * n)
@@ -7483,19 +7275,19 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      *
-     * The `addMany` function takes in a collection of nodes and an optional collection of values, and
+     * The `addMany` function takes in a collection of keysOrNodesOrEntries and an optional collection of values, and
      * adds each node with its corresponding value to the data structure.
-     * @param nodes - An iterable collection of BTNExemplar objects.
+     * @param keysOrNodesOrEntries - An iterable collection of KeyOrNodeOrEntry objects.
      * @param [values] - An optional iterable of values that will be assigned to each node being added.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(nodes, values) {
+    addMany(keysOrNodesOrEntries, values) {
       const inserted = [];
       let valuesIterator;
       if (values) {
         valuesIterator = values[Symbol.iterator]();
       }
-      for (const kne of nodes) {
+      for (const keyOrNodeOrEntry of keysOrNodesOrEntries) {
         let value = void 0;
         if (valuesIterator) {
           const valueResult = valuesIterator.next();
@@ -7503,17 +7295,30 @@ var dataStructureTyped = (() => {
             value = valueResult.value;
           }
         }
-        inserted.push(this.add(kne, value));
+        inserted.push(this.add(keyOrNodeOrEntry, value));
       }
       return inserted;
     }
     /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     * Time Complexity: O(k * n)
+     * Space Complexity: O(1)
+     * "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     */
+    /**
+     * Time Complexity: O(k * n)
      * Space Complexity: O(1)
+     *
+     * The `refill` function clears the current data and adds new key-value pairs to the data structure.
+     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries. These can be of type
+     * KeyOrNodeOrEntry<K, V, N>.
+     * @param [values] - The `values` parameter is an optional iterable that contains the values to be
+     * associated with the keys or nodes or entries in the `keysOrNodesOrEntries` parameter. If provided,
+     * the values will be associated with the corresponding keys or nodes or entries in the
+     * `keysOrNodesOrEntries` iterable
      */
-    refill(nodesOrKeysOrEntries, values) {
+    refill(keysOrNodesOrEntries, values) {
       this.clear();
-      this.addMany(nodesOrKeysOrEntries, values);
+      this.addMany(keysOrNodesOrEntries, values);
     }
     /**
      * Time Complexity: O(n)
@@ -7583,24 +7388,24 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function calculates the depth of a given node in a binary tree.
-     * @param {K | N | null | undefined} distNode - The `distNode` parameter represents the node in
+     * @param {K | N | null | undefined} dist - The `dist` parameter represents the node in
      * the binary tree whose depth we want to find. It can be of type `K`, `N`, `null`, or
      * `undefined`.
      * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
      * `N` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
-     * @returns the depth of the `distNode` relative to the `beginRoot`.
+     * @returns the depth of the `dist` relative to the `beginRoot`.
      */
-    getDepth(distNode, beginRoot = this.root) {
-      distNode = this.ensureNode(distNode);
+    getDepth(dist, beginRoot = this.root) {
+      dist = this.ensureNode(dist);
       beginRoot = this.ensureNode(beginRoot);
       let depth = 0;
-      while (distNode == null ? void 0 : distNode.parent) {
-        if (distNode === beginRoot) {
+      while (dist == null ? void 0 : dist.parent) {
+        if (dist === beginRoot) {
           return depth;
         }
         depth++;
-        distNode = distNode.parent;
+        dist = dist.parent;
       }
       return depth;
     }
@@ -7792,6 +7597,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
+     * Space Complexity: O(log n).
      *
      * The function checks if a Binary Tree Node with a specific identifier exists in the tree.
      * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
@@ -7888,24 +7694,6 @@ var dataStructureTyped = (() => {
         }
       }
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
-    /**
-     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
-     * key, otherwise it returns the key itself.
-     * @param {K | N | null | undefined} key - The `key` parameter can be of type `K`, `N`,
-     * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be used when searching for a node by key. It has a default value of
-     * `IterationType.ITERATIVE`.
-     * @returns either the node corresponding to the given key if it is a valid node key, or the key
-     * itself if it is not a valid node key.
-     */
-    ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -7935,10 +7723,13 @@ var dataStructureTyped = (() => {
       return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value) != null ? _b : void 0;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Clear the binary tree, removing all nodes.
      */
     clear() {
@@ -7946,6 +7737,13 @@ var dataStructureTyped = (() => {
       this._size = 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Check if the binary tree is empty.
      * @returns {boolean} - True if the binary tree is empty, false otherwise.
      */
@@ -7980,7 +7778,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(log n)
@@ -8071,7 +7869,7 @@ var dataStructureTyped = (() => {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
+    isBST(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return true;
@@ -8084,45 +7882,32 @@ var dataStructureTyped = (() => {
             return false;
           return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
         };
-        return dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        const isStandardBST = dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        const isInverseBST = dfs(beginRoot, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+        return isStandardBST || isInverseBST;
       } else {
-        const stack = [];
-        let prev = Number.MIN_SAFE_INTEGER, curr = beginRoot;
-        while (curr || stack.length > 0) {
-          while (curr) {
-            stack.push(curr);
-            curr = curr.left;
+        const checkBST = (checkMax = false) => {
+          const stack = [];
+          let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
+          let curr = beginRoot;
+          while (curr || stack.length > 0) {
+            while (curr) {
+              stack.push(curr);
+              curr = curr.left;
+            }
+            curr = stack.pop();
+            const numKey = this.extractor(curr.key);
+            if (!curr || !checkMax && prev >= numKey || checkMax && prev <= numKey)
+              return false;
+            prev = numKey;
+            curr = curr.right;
           }
-          curr = stack.pop();
-          const numKey = this.extractor(curr.key);
-          if (!curr || prev >= numKey)
-            return false;
-          prev = numKey;
-          curr = curr.right;
-        }
-        return true;
+          return true;
+        };
+        const isStandardBST = checkBST(false), isInverseBST = checkBST(true);
+        return isStandardBST || isInverseBST;
       }
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a binary tree is a binary search tree.
-     * @param iterationType - The parameter "iterationType" is used to specify the type of iteration to
-     * be used when checking if the binary tree is a binary search tree (BST). It is an optional
-     * parameter with a default value of "this.iterationType". The value of "this.iterationType" is
-     * expected to be
-     * @returns a boolean value.
-     */
-    isBST(iterationType = this.iterationType) {
-      if (this.root === null)
-        return true;
-      return this.isSubtreeBST(this.root, iterationType);
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(log n)
@@ -8142,7 +7927,7 @@ var dataStructureTyped = (() => {
      * whether to include null values in the traversal. If `includeNull` is set to `true`, the
      * traversal will include null values, otherwise it will skip them.
      * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
-     * the `callback` function on each node in the subtree. The type of the array elements is determined
+     * the `callback` function on each node in the subtree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
     subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
@@ -8182,44 +7967,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
-    /**
-     * The function checks if a given node is a real node by verifying if it is an instance of
-     * BinaryTreeNode and its key is not NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isRealNode(node) {
-      return node instanceof BinaryTreeNode && String(node.key) !== "NaN";
-    }
-    /**
-     * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isNIL(node) {
-      return node instanceof BinaryTreeNode && String(node.key) === "NaN";
-    }
-    /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isNodeOrNull(node) {
-      return this.isRealNode(node) || node === null;
-    }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof BinaryTreeNode);
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -8527,7 +8274,12 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time complexity: O(n)
-     * Space complexity: O(1)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
      * The `morris` function performs a depth-first traversal on a binary tree using the Morris traversal
      * algorithm.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
@@ -8540,7 +8292,7 @@ var dataStructureTyped = (() => {
      * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
      * the root of the tree. If no value is provided, the default value is the root of the tree.
      * @returns The function `morris` returns an array of values that are the result of invoking the
-     * `callback` function on each node in the binary tree. The type of the array elements is determined
+     * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
     morris(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root) {
@@ -8649,8 +8401,8 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function creates a new tree by iterating over the elements of the current tree and
-     * adding only the elements that satisfy the given predicate function.
+     * The `filter` function creates a new tree by iterating over the nodes of the current tree and
+     * adding only the nodes that satisfy the given predicate function.
      * @param predicate - The `predicate` parameter is a function that takes three arguments: `value`,
      * `key`, and `index`. It should return a boolean value indicating whether the pair should be
      * included in the filtered tree or not.
@@ -8707,6 +8459,13 @@ var dataStructureTyped = (() => {
     // // }
     //
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The `print` function is used to display a binary tree structure in a visually appealing way.
      * @param {K | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
@@ -8909,25 +8668,24 @@ var dataStructureTyped = (() => {
   var BST = class _BST extends BinaryTree {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
-     * the tree with optional elements and options.
-     * @param [elements] - An optional iterable of BTNExemplar objects that will be added to the
+     * the tree with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
-    constructor(elements, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "_root");
-      __publicField(this, "_variant", "MIN" /* MIN */);
+      __publicField(this, "_variant", "STANDARD" /* STANDARD */);
       if (options) {
         const { variant } = options;
-        if (variant) {
+        if (variant)
           this._variant = variant;
-        }
       }
       this._root = void 0;
-      if (elements)
-        this.addMany(elements);
+      if (keysOrNodesOrEntries)
+        this.addMany(keysOrNodesOrEntries);
     }
     get root() {
       return this._root;
@@ -8960,48 +8718,88 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, 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 node if the exemplar is valid,
+     * The function `exemplarToNode` takes an keyOrNodeOrEntry and returns a node if the keyOrNodeOrEntry is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the exemplar node.
+     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node.
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar, value) {
+    exemplarToNode(keyOrNodeOrEntry, value) {
       let node;
-      if (exemplar === null || exemplar === void 0) {
+      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return;
-      } else if (this.isNode(exemplar)) {
-        node = exemplar;
-      } else if (this.isEntry(exemplar)) {
-        const [key, value2] = exemplar;
+      } 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);
         }
-      } else if (this.isNotNodeInstance(exemplar)) {
-        node = this.createNode(exemplar, value);
+      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value);
       } 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. Space for the recursive call stack in the worst case.
      */
     /**
-     * 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     *
+     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
+     * otherwise it returns the key itself.
+     * @param {K | N | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`, or
+     * `undefined`.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+     * @returns either a node object (N) or undefined.
+     */
+    ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE" /* ITERATIVE */) {
+      let res;
+      if (this.isRealNode(keyOrNodeOrEntry)) {
+        res = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        if (keyOrNodeOrEntry[0])
+          res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+      } else {
+        if (keyOrNodeOrEntry)
+          res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+      }
+      return res;
+    }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof BSTNode);
+    }
+    /**
+     * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the BSTNode class.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof BSTNode;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *  - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The `add` function adds a new node to a binary tree, updating the value if the key already exists
      * or inserting a new node if the key is unique.
@@ -9014,23 +8812,23 @@ var dataStructureTyped = (() => {
     add(keyOrNodeOrEntry, value) {
       const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
-        return;
+        return false;
       if (this.root === void 0) {
         this._setRoot(newNode);
         this._size++;
-        return this.root;
+        return true;
       }
       let current = this.root;
       while (current !== void 0) {
         if (this._compare(current.key, newNode.key) === "eq" /* eq */) {
           this._replaceNode(current, newNode);
-          return newNode;
+          return true;
         } else if (this._compare(current.key, newNode.key) === "gt" /* gt */) {
           if (current.left === void 0) {
             current.left = newNode;
             newNode.parent = current;
             this._size++;
-            return newNode;
+            return true;
           }
           current = current.left;
         } else {
@@ -9038,20 +8836,21 @@ var dataStructureTyped = (() => {
             current.right = newNode;
             newNode.parent = current;
             this._size++;
-            return newNode;
+            return true;
           }
           current = current.right;
         }
       }
-      return void 0;
+      return false;
     }
     /**
-     * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(k) - Additional space is required for the sorted array.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(k)
+     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(k) - Additional space is required for the sorted array.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(k)
      *
      * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
      * balancing the tree after each addition.
@@ -9062,7 +8861,7 @@ var dataStructureTyped = (() => {
      * order. If not provided, undefined will be assigned as the value for each key or node.
      * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
      * balanced or not. If set to true, the add operation will be balanced using a binary search tree
-     * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+     * algorithm. If set to false, the add operation will not be balanced and the nodes will be added
      * in the order they appear in the input.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when adding multiple keys or nodes. It has a default value of
@@ -9143,20 +8942,19 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
      * leftmost node if the comparison result is greater than.
      * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
      * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
      * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed. It can have one of the following values:
      * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
@@ -9165,7 +8963,7 @@ var dataStructureTyped = (() => {
       let current = this.ensureNode(beginRoot);
       if (!current)
         return void 0;
-      if (this._variant === "MIN" /* MIN */) {
+      if (this._variant === "STANDARD" /* STANDARD */) {
         while (current.right !== void 0) {
           current = current.right;
         }
@@ -9177,12 +8975,12 @@ var dataStructureTyped = (() => {
       return current.key;
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
      * either recursive or iterative methods.
@@ -9225,53 +9023,34 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof BSTNode);
-    }
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     */
-    /**
-     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
-     * otherwise it returns the key itself.
-     * @param {K | N | undefined} key - The `key` parameter can be of type `K`, `N`, or
-     * `undefined`.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
-     * @returns either a node object (N) or undefined.
-     */
-    ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
-    }
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     *
-     * The function `getNodes` returns an array of nodes that match a given identifier, using either a
-     * recursive or iterative approach.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
-     * want to search for in the nodes of the binary tree. It can be of any type that is returned by the
-     * callback function `C`.
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` as its
-     * argument and returns a value of type `ReturnType<C>`. The `C` type parameter represents a callback
-     * function type that extends the `BTNCallback<N>` type. The `BTNCallback<N>` type is
-     * @param [onlyOne=false] - A boolean flag indicating whether to stop searching after finding the
-     * first node that matches the identifier. If set to true, the function will return an array
-     * containing only the first matching node. If set to false (default), the function will continue
-     * searching for all nodes that match the identifier and return an array containing
-     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
-     * for the traversal. It can be either a key value or a node object. If it is undefined, the
-     * traversal will start from the root of the tree.
-     * @param iterationType - The `iterationType` parameter determines the type of iteration to be
-     * performed on the binary tree. It can have two possible values:
-     * @returns The method returns an array of nodes (`N[]`).
-     */
+       * Time Complexity: O(log n)
+       * Space Complexity: O(log n)
+       * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. Space for the recursive call stack in the worst case.
+       * /
+    
+       /**
+       * Time Complexity: O(log n)
+       * Space Complexity: O(log n)
+       *
+       * The function `getNodes` returns an array of nodes that match a given identifier, using either a
+       * recursive or iterative approach.
+       * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
+       * want to search for in the nodes of the binary tree. It can be of any type that is returned by the
+       * callback function `C`.
+       * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` as its
+       * argument and returns a value of type `ReturnType<C>`. The `C` type parameter represents a callback
+       * function type that extends the `BTNCallback<N>` type. The `BTNCallback<N>` type is
+       * @param [onlyOne=false] - A boolean flag indicating whether to stop searching after finding the
+       * first node that matches the identifier. If set to true, the function will return an array
+       * containing only the first matching node. If set to false (default), the function will continue
+       * searching for all nodes that match the identifier and return an array containing
+       * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
+       * for the traversal. It can be either a key value or a node object. If it is undefined, the
+       * traversal will start from the root of the tree.
+       * @param iterationType - The `iterationType` parameter determines the type of iteration to be
+       * performed on the binary tree. It can have two possible values:
+       * @returns The method returns an array of nodes (`N[]`).
+       */
     getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
@@ -9324,12 +9103,13 @@ var dataStructureTyped = (() => {
       return ans;
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. Space for the recursive call stack in the worst case.
      */
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      *
      * The `lesserOrGreaterTraverse` function traverses a binary tree and returns an array of nodes that
      * are either lesser or greater than a target node, depending on the specified comparison type.
@@ -9388,12 +9168,12 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      */
     /**
-     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      *
      * The `perfectlyBalance` function balances a binary search tree by adding nodes in a way that
      * ensures the tree is perfectly balanced.
@@ -9451,8 +9231,8 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      *
      * The function checks if a binary tree is AVL balanced using either recursive or iterative approach.
      * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
@@ -9519,7 +9299,7 @@ var dataStructureTyped = (() => {
     _compare(a, b) {
       const extractedA = this.extractor(a);
       const extractedB = this.extractor(b);
-      const compared = this.variant === "MIN" /* MIN */ ? extractedA - extractedB : extractedB - extractedA;
+      const compared = this.variant === "STANDARD" /* STANDARD */ ? extractedA - extractedB : extractedB - extractedA;
       return compared > 0 ? "gt" /* gt */ : compared < 0 ? "lt" /* lt */ : "eq" /* eq */;
     }
   };
@@ -9960,18 +9740,18 @@ var dataStructureTyped = (() => {
   };
   var AVLTree = class _AVLTree extends BST {
     /**
-     * The constructor function initializes an AVLTree object with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
-     * objects. It represents a collection of elements that will be added to the AVL tree during
+     * The constructor function initializes an AVLTree object with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * objects. It represents a collection of nodes that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
      * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
      * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
      */
-    constructor(elements, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
-      if (elements)
-        super.addMany(elements);
+      if (keysOrNodesOrEntries)
+        super.addMany(keysOrNodesOrEntries);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -9999,12 +9779,12 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of AVLTreeNode.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
+     * The function checks if an keyOrNodeOrEntry is an instance of AVLTreeNode.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeNode class.
      */
-    isNode(exemplar) {
-      return exemplar instanceof AVLTreeNode;
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof AVLTreeNode;
     }
     /**
      * The function "isNotNodeInstance" checks if a potential key is a K.
@@ -10016,12 +9796,13 @@ var dataStructureTyped = (() => {
       return !(potentialKey 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the add method of a binary tree node and balances the tree after inserting
      * a new node.
@@ -10033,19 +9814,19 @@ var dataStructureTyped = (() => {
      */
     add(keyOrNodeOrEntry, value) {
       if (keyOrNodeOrEntry === null)
-        return void 0;
+        return false;
       const inserted = super.add(keyOrNodeOrEntry, value);
       if (inserted)
-        this._balancePath(inserted);
+        this._balancePath(keyOrNodeOrEntry);
       return inserted;
     }
     /**
-     * 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the delete method of a binary tree, performs the deletion, and then
      * balances the tree if necessary.
@@ -10099,12 +9880,13 @@ var dataStructureTyped = (() => {
       return void 0;
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * constant time, as it performs a fixed number of operations. constant space, as it only uses a constant amount of memory.
      */
     /**
-     * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function calculates the balance factor of a node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
@@ -10120,12 +9902,13 @@ var dataStructureTyped = (() => {
         return node.right.height - node.left.height;
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * constant time, as it performs a fixed number of operations. constant space, as it only uses a constant amount of memory.
      */
     /**
-     * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function updates the height of a node in a binary tree based on the heights of its left and
      * right children.
@@ -10143,12 +9926,13 @@ var dataStructureTyped = (() => {
         node.height = 1 + Math.max(node.right.height, node.left.height);
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
@@ -10156,6 +9940,7 @@ var dataStructureTyped = (() => {
      * AVL tree that needs to be balanced.
      */
     _balancePath(node) {
+      node = this.ensureNode(node);
       const path = this.getPathToRoot(node, false);
       for (let i = 0; i < path.length; i++) {
         const A = path[i];
@@ -10182,12 +9967,13 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * constant time, as these methods perform a fixed number of operations. constant space, as they only use a constant amount of memory.
      */
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function `_balanceLL` performs a left-left rotation to balance a binary tree.
      * @param {N} A - A is a node in a binary tree.
@@ -10221,12 +10007,12 @@ var dataStructureTyped = (() => {
         this._updateHeight(B);
     }
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
      * @param {N} A - A is a node in a binary tree.
@@ -10275,12 +10061,12 @@ var dataStructureTyped = (() => {
       C && this._updateHeight(C);
     }
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
      * @param {N} A - A is a node in a binary tree.
@@ -10315,12 +10101,12 @@ var dataStructureTyped = (() => {
       B && this._updateHeight(B);
     }
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-     * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
      * @param {N} A - A is a node in a binary tree.
@@ -10385,23 +10171,23 @@ var dataStructureTyped = (() => {
   var RedBlackTree = class _RedBlackTree extends BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
-     * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
-     * objects. It represents the initial elements that will be added to the RBTree during its
+     * initializes the tree with optional nodes and options.
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
-     * elements to the
+     * nodes to the
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(elements, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "Sentinel", new RedBlackTreeNode(NaN));
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
       this._root = this.Sentinel;
-      if (elements)
-        super.addMany(elements);
+      if (keysOrNodesOrEntries)
+        super.addMany(keysOrNodesOrEntries);
     }
     get root() {
       return this._root;
@@ -10438,57 +10224,67 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, 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 "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof RedBlackTreeNode);
-    }
-    /**
-     * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
+     * The function `exemplarToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
+     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar, value) {
+    exemplarToNode(keyOrNodeOrEntry, value) {
       let node;
-      if (exemplar === null || exemplar === void 0) {
+      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return;
-      } else if (this.isNode(exemplar)) {
-        node = exemplar;
-      } else if (this.isEntry(exemplar)) {
-        const [key, value2] = exemplar;
+      } 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, 1 /* RED */);
         }
-      } else if (this.isNotNodeInstance(exemplar)) {
-        node = this.createNode(exemplar, value, 1 /* RED */);
+      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value, 1 /* RED */);
       } else {
         return;
       }
       return node;
     }
+    /**
+     * The function checks if an keyOrNodeOrEntry is an instance of the RedBlackTreeNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the RedBlackTreeNode
+     * class.
+     */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof RedBlackTreeNode;
+    }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
      */
+    isRealNode(node) {
+      if (node === this.Sentinel || node === void 0)
+        return false;
+      return node instanceof RedBlackTreeNode;
+    }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof RedBlackTreeNode);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *  on average (where n is the number of nodes in the tree)
+     */
+    /**
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `add` function adds a new node to a binary search tree and performs necessary rotations and
@@ -10502,7 +10298,7 @@ var dataStructureTyped = (() => {
     add(keyOrNodeOrEntry, value) {
       const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
-        return;
+        return false;
       newNode.left = this.Sentinel;
       newNode.right = this.Sentinel;
       let y = void 0;
@@ -10518,7 +10314,7 @@ var dataStructureTyped = (() => {
             if (newNode !== x) {
               this._replaceNode(x, newNode);
             }
-            return;
+            return false;
           }
         }
       }
@@ -10533,21 +10329,23 @@ var dataStructureTyped = (() => {
       if (newNode.parent === void 0) {
         newNode.color = 0 /* BLACK */;
         this._size++;
-        return;
+        return false;
       }
       if (newNode.parent.parent === void 0) {
         this._size++;
-        return;
+        return false;
       }
       this._fixInsert(newNode);
       this._size++;
+      return true;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     *  on average (where n is the number of nodes in the tree)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes a node from a binary tree based on a given identifier and updates
@@ -10615,20 +10413,11 @@ var dataStructureTyped = (() => {
       return ans;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    isRealNode(node) {
-      if (node === this.Sentinel || node === void 0)
-        return false;
-      return node instanceof RedBlackTreeNode;
-    }
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function `getNode` retrieves a single node from a binary tree based on a given identifier and
@@ -10680,7 +10469,7 @@ var dataStructureTyped = (() => {
       return y;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     clear() {
@@ -10757,11 +10546,11 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function `_fixDelete` is used to fix the red-black tree after a node deletion.
@@ -10851,11 +10640,11 @@ var dataStructureTyped = (() => {
       v.parent = u.parent;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
@@ -10938,11 +10727,11 @@ var dataStructureTyped = (() => {
     }
   };
   var TreeMultimap = class _TreeMultimap extends AVLTree {
-    constructor(elements, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
-      if (elements)
-        this.addMany(elements);
+      if (keysOrNodesOrEntries)
+        this.addMany(keysOrNodesOrEntries);
     }
     // TODO the _count is not accurate after nodes count modified
     get count() {
@@ -10969,26 +10758,8 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, 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 "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-      return !(potentialKey instanceof TreeMultimapNode);
-    }
-    /**
-     * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
+     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -10997,33 +10768,52 @@ var dataStructureTyped = (() => {
      * times the value should be added to the node. If not provided, it defaults to 1.
      * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar, value, count = 1) {
+    exemplarToNode(keyOrNodeOrEntry, value, count = 1) {
       let node;
-      if (exemplar === void 0 || exemplar === null) {
+      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
         return;
-      } else if (this.isNode(exemplar)) {
-        node = exemplar;
-      } else if (this.isEntry(exemplar)) {
-        const [key, value2] = exemplar;
+      } 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.isNotNodeInstance(exemplar)) {
-        node = this.createNode(exemplar, value, count);
+      } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, value, 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.
+     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * class.
      */
+    isNode(keyOrNodeOrEntry) {
+      return keyOrNodeOrEntry instanceof TreeMultimapNode;
+    }
     /**
-     * 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.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof TreeMultimapNode);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the add method of a binary tree node and adds a new node to the tree.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
@@ -11040,21 +10830,22 @@ var dataStructureTyped = (() => {
     add(keyOrNodeOrEntry, value, count = 1) {
       const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
       if (newNode === void 0)
-        return;
+        return false;
       const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
       const inserted = super.add(newNode);
       if (inserted) {
         this._count += orgNodeCount;
       }
-      return inserted;
+      return true;
     }
     /**
-     * Time Complexity: O(k 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.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k 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.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
      * structure.
@@ -11066,12 +10857,13 @@ var dataStructureTyped = (() => {
       return super.addMany(keysOrNodesOrEntries);
     }
     /**
-     * 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.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
      */
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
@@ -11116,12 +10908,13 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete 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.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
      * account the count of the node and balancing the tree if necessary.
@@ -11191,10 +10984,13 @@ var dataStructureTyped = (() => {
       return deletedResult;
     }
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear() {
@@ -11295,14 +11091,14 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/priority-queue/priority-queue.ts
   var PriorityQueue = class extends Heap {
-    constructor(elements, options) {
+    constructor(elements = [], options) {
       super(elements, options);
     }
   };
 
   // src/data-structures/priority-queue/min-priority-queue.ts
   var MinPriorityQueue = class extends PriorityQueue {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -11317,7 +11113,7 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/priority-queue/max-priority-queue.ts
   var MaxPriorityQueue = class extends PriorityQueue {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -11846,18 +11642,19 @@ var dataStructureTyped = (() => {
     }
   };
   var Trie = class _Trie extends IterableElementBase {
-    constructor(words, caseSensitive = true) {
+    constructor(words = [], options) {
       super();
-      __publicField(this, "_size");
-      __publicField(this, "_caseSensitive");
-      __publicField(this, "_root");
-      this._root = new TrieNode("");
-      this._caseSensitive = caseSensitive;
-      this._size = 0;
+      __publicField(this, "_size", 0);
+      __publicField(this, "_caseSensitive", true);
+      __publicField(this, "_root", new TrieNode(""));
+      if (options) {
+        const { caseSensitive } = options;
+        if (caseSensitive !== void 0)
+          this._caseSensitive = caseSensitive;
+      }
       if (words) {
-        for (const word of words) {
+        for (const word of words)
           this.add(word);
-        }
       }
     }
     get size() {