data-structure-typed 1.49.6 → 1.49.8

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");
@@ -7315,15 +7036,15 @@ var dataStructureTyped = (() => {
   };
   var BinaryTree = class _BinaryTree extends IterableEntryBase {
     /**
-     * The constructor function initializes a binary tree object with optional nodes and options.
-     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * 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(nodes, 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 (nodes)
-        this.addMany(nodes);
+      if (keysOrNodesOrEntries)
+        this.addMany(keysOrNodesOrEntries);
     }
     get extractor() {
       return this._extractor;
@@ -8409,9 +8128,9 @@ var dataStructureTyped = (() => {
             if (current && this.isNodeOrNull(current.right))
               queue.push(current.right);
           } else {
-            if (current.left)
+            if (this.isRealNode(current.left))
               queue.push(current.left);
-            if (current.right)
+            if (this.isRealNode(current.right))
               queue.push(current.right);
           }
           traverse(level + 1);
@@ -8430,9 +8149,9 @@ var dataStructureTyped = (() => {
               if (current && this.isNodeOrNull(current.right))
                 queue.push(current.right);
             } else {
-              if (current.left)
+              if (this.isRealNode(current.left))
                 queue.push(current.left);
-              if (current.right)
+              if (this.isRealNode(current.right))
                 queue.push(current.right);
             }
           }
@@ -8949,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 nodes and options.
-     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry 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(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "_root");
       __publicField(this, "_variant", "STANDARD" /* STANDARD */);
       if (options) {
         const { variant } = options;
-        if (variant) {
+        if (variant)
           this._variant = variant;
-        }
       }
       this._root = void 0;
-      if (nodes)
-        this.addMany(nodes);
+      if (keysOrNodesOrEntries)
+        this.addMany(keysOrNodesOrEntries);
     }
     get root() {
       return this._root;
@@ -10022,18 +9740,18 @@ var dataStructureTyped = (() => {
   };
   var AVLTree = class _AVLTree extends BST {
     /**
-     * The constructor function initializes an AVLTree object with optional nodes and options.
-     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * 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(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
-      if (nodes)
-        super.addMany(nodes);
+      if (keysOrNodesOrEntries)
+        super.addMany(keysOrNodesOrEntries);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -10454,7 +10172,7 @@ var dataStructureTyped = (() => {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
-     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @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
      * nodes to the
@@ -10462,14 +10180,14 @@ var dataStructureTyped = (() => {
      * 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(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "Sentinel", new RedBlackTreeNode(NaN));
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
       this._root = this.Sentinel;
-      if (nodes)
-        super.addMany(nodes);
+      if (keysOrNodesOrEntries)
+        super.addMany(keysOrNodesOrEntries);
     }
     get root() {
       return this._root;
@@ -10501,8 +10219,7 @@ var dataStructureTyped = (() => {
      */
     createTree(options) {
       return new _RedBlackTree([], __spreadValues({
-        iterationType: this.iterationType,
-        variant: this.variant
+        iterationType: this.iterationType
       }, options));
     }
     /**
@@ -10690,6 +10407,7 @@ var dataStructureTyped = (() => {
           this._fixDelete(x);
         }
         this._size--;
+        ans.push({ deleted: z, needBalanced: void 0 });
       };
       helper(this.root);
       return ans;
@@ -11009,11 +10727,11 @@ var dataStructureTyped = (() => {
     }
   };
   var TreeMultimap = class _TreeMultimap extends AVLTree {
-    constructor(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
       __publicField(this, "_count", 0);
-      if (nodes)
-        this.addMany(nodes);
+      if (keysOrNodesOrEntries)
+        this.addMany(keysOrNodesOrEntries);
     }
     // TODO the _count is not accurate after nodes count modified
     get count() {
@@ -11373,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");
@@ -11395,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");
@@ -11924,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() {