min-heap-typed 1.50.1 → 1.50.2

package/dist/data-structures/queue/deque.js

@@ -11,6 +11,17 @@ const utils_1 = require("../../utils");
  * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
  */
 class Deque extends base_1.IterableElementBase {
+    /**
+     * The constructor initializes a Deque object with an optional iterable of elements and options.
+     * @param elements - An iterable object (such as an array or a Set) that contains the initial
+     * elements to be added to the deque. It can also be an object with a `length` or `size` property
+     * that represents the number of elements in the iterable object. If no elements are provided, an
+     * empty deque
+     * @param {DequeOptions} [options] - The `options` parameter is an optional object that can contain
+     * configuration options for the deque. In this code, it is used to set the `bucketSize` option,
+     * which determines the size of each bucket in the deque. If the `bucketSize` option is not provided
+     * or is not a number
+     */
     constructor(elements = [], options) {
         super();
         this._bucketFirst = 0;
@@ -50,9 +61,26 @@ class Deque extends base_1.IterableElementBase {
             this.push(element);
         }
     }
+    /**
+     * The bucketSize function returns the size of the bucket.
+     *
+     * @return The size of the bucket
+     */
+    get bucketSize() {
+        return this._bucketSize;
+    }
+    /**
+     * The buckets function returns the buckets property of the object.
+     *
+     * @return The buckets property
+     */
     get buckets() {
         return this._buckets;
     }
+    /**
+     * The size function returns the number of items in the stack.
+     * @return The number of values in the set
+     */
     get size() {
         return this._size;
     }
@@ -66,6 +94,10 @@ class Deque extends base_1.IterableElementBase {
             return;
         return this._buckets[this._bucketFirst][this._firstInBucket];
     }
+    /**
+     * The last function returns the last element in the queue.
+     * @return The last element in the array
+     */
     get last() {
         if (this.size === 0)
             return;
@@ -226,7 +258,7 @@ class Deque extends base_1.IterableElementBase {
     *begin() {
         let index = 0;
         while (index < this.size) {
-            yield this.getAt(index);
+            yield this.at(index);
             index++;
         }
     }
@@ -237,7 +269,7 @@ class Deque extends base_1.IterableElementBase {
     *reverseBegin() {
         let index = this.size - 1;
         while (index >= 0) {
-            yield this.getAt(index);
+            yield this.at(index);
             index--;
         }
     }
@@ -249,13 +281,13 @@ class Deque extends base_1.IterableElementBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `getAt` function retrieves an element at a specified position in an array-like data structure.
+     * The `at` function retrieves an element at a specified position in an array-like data structure.
      * @param {number} pos - The `pos` parameter represents the position of the element that you want to
      * retrieve from the data structure. It is of type `number` and should be a valid index within the
      * range of the data structure.
      * @returns The element at the specified position in the data structure is being returned.
      */
-    getAt(pos) {
+    at(pos) {
         (0, utils_1.rangeCheck)(pos, 0, this.size - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         return this._buckets[bucketIndex][indexInBucket];
@@ -313,9 +345,9 @@ class Deque extends base_1.IterableElementBase {
         else {
             const arr = [];
             for (let i = pos; i < this.size; ++i) {
-                arr.push(this.getAt(i));
+                arr.push(this.at(i));
             }
-            this.cut(pos - 1);
+            this.cut(pos - 1, true);
             for (let i = 0; i < num; ++i)
                 this.push(element);
             for (let i = 0; i < arr.length; ++i)
@@ -335,18 +367,48 @@ class Deque extends base_1.IterableElementBase {
      * updated size.
      * @param {number} pos - The `pos` parameter represents the position at which the string should be
      * cut. It is a number that indicates the index of the character where the cut should be made.
+     * @param {boolean} isCutSelf - If true, the original deque will not be cut, and return a new deque
      * @returns The method is returning the updated size of the data structure.
      */
-    cut(pos) {
-        if (pos < 0) {
-            this.clear();
-            return 0;
+    cut(pos, isCutSelf = false) {
+        if (isCutSelf) {
+            if (pos < 0) {
+                this.clear();
+                return this;
+            }
+            const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+            this._bucketLast = bucketIndex;
+            this._lastInBucket = indexInBucket;
+            this._size = pos + 1;
+            return this;
+        }
+        else {
+            const newDeque = new Deque([], { bucketSize: this._bucketSize });
+            for (let i = 0; i <= pos; i++) {
+                newDeque.push(this.at(i));
+            }
+            return newDeque;
+        }
+    }
+    cutRest(pos, isCutSelf = false) {
+        if (isCutSelf) {
+            if (pos < 0) {
+                this.clear();
+                return this;
+            }
+            const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+            this._bucketFirst = bucketIndex;
+            this._firstInBucket = indexInBucket;
+            this._size = this._size - pos;
+            return this;
+        }
+        else {
+            const newDeque = new Deque([], { bucketSize: this._bucketSize });
+            for (let i = pos; i < this.size; i++) {
+                newDeque.push(this.at(i));
+            }
+            return newDeque;
         }
-        const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
-        this._bucketLast = bucketIndex;
-        this._lastInBucket = indexInBucket;
-        this._size = pos + 1;
-        return this.size;
     }
     /**
      * Time Complexity: O(n)
@@ -403,14 +465,14 @@ class Deque extends base_1.IterableElementBase {
         let i = 0;
         let index = 0;
         while (i < size) {
-            const oldElement = this.getAt(i);
+            const oldElement = this.at(i);
             if (oldElement !== element) {
                 this.setAt(index, oldElement);
                 index += 1;
             }
             i += 1;
         }
-        this.cut(index - 1);
+        this.cut(index - 1, true);
         return true;
     }
     /**
@@ -454,15 +516,15 @@ class Deque extends base_1.IterableElementBase {
             return this;
         }
         let index = 1;
-        let prev = this.getAt(0);
+        let prev = this.at(0);
         for (let i = 1; i < this.size; ++i) {
-            const cur = this.getAt(i);
+            const cur = this.at(i);
             if (cur !== prev) {
                 prev = cur;
                 this.setAt(index++, cur);
             }
         }
-        this.cut(index - 1);
+        this.cut(index - 1, true);
         return this;
     }
     /**
@@ -482,7 +544,7 @@ class Deque extends base_1.IterableElementBase {
     sort(comparator) {
         const arr = [];
         for (let i = 0; i < this.size; ++i) {
-            arr.push(this.getAt(i));
+            arr.push(this.at(i));
         }
         arr.sort(comparator);
         for (let i = 0; i < this.size; ++i) {
@@ -526,30 +588,6 @@ class Deque extends base_1.IterableElementBase {
         this._bucketLast = newBuckets.length - 1;
         this._buckets = newBuckets;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `find` function iterates over the elements in a deque and returns the first element for which
-     * the callback function returns true, or undefined if no such element is found.
-     * @param callback - A function that takes three parameters: element, index, and deque. It should
-     * return a boolean value indicating whether the element satisfies a certain condition.
-     * @returns The method `find` returns the first element in the deque that satisfies the condition
-     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
-     */
-    find(callback) {
-        for (let i = 0; i < this.size; ++i) {
-            const element = this.getAt(i);
-            if (callback(element, i, this)) {
-                return element;
-            }
-        }
-        return;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -567,7 +605,7 @@ class Deque extends base_1.IterableElementBase {
      */
     indexOf(element) {
         for (let i = 0; i < this.size; ++i) {
-            if (this.getAt(i) === element) {
+            if (this.at(i) === element) {
                 return i;
             }
         }
@@ -587,6 +625,22 @@ class Deque extends base_1.IterableElementBase {
     toArray() {
         return [...this];
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone()` function returns a new instance of the `Deque` class with the same elements and
+     * bucket size as the original instance.
+     * @returns The `clone()` method is returning a new instance of the `Deque` class with the same
+     * elements as the original deque (`this`) and the same bucket size.
+     */
+    clone() {
+        return new Deque([...this], { bucketSize: this.bucketSize });
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -704,7 +758,7 @@ class Deque extends base_1.IterableElementBase {
      */
     *_getIterator() {
         for (let i = 0; i < this.size; ++i) {
-            yield this.getAt(i);
+            yield this.at(i);
         }
     }
     /**

package/dist/data-structures/queue/queue.d.ts

@@ -24,8 +24,16 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      */
     constructor(elements?: Iterable<E>);
     protected _elements: E[];
+    /**
+     * The elements function returns the elements of this set.
+     * @return An array of the elements in the stack
+     */
     get elements(): E[];
     protected _offset: number;
+    /**
+     * The offset function returns the offset of the current page.
+     * @return The value of the private variable _offset
+     */
     get offset(): number;
     /**
      * The size function returns the number of elements in an array.
@@ -93,6 +101,18 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
      */
     shift(): E | undefined;
+    /**
+     * The delete function removes an element from the list.
+     * @param element: E Specify the element to be deleted
+     * @return A boolean value indicating whether the element was successfully deleted or not
+     */
+    delete(element: E): boolean;
+    /**
+     * The deleteAt function deletes the element at a given index.
+     * @param index: number Determine the index of the element to be deleted
+     * @return A boolean value
+     */
+    deleteAt(index: number): boolean;
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -153,7 +173,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      *
      * @param index
      */
-    getAt(index: number): E | undefined;
+    at(index: number): E | undefined;
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
      * Space Complexity: O(1) - no additional space is used.
@@ -183,12 +203,13 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      */
     clear(): void;
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * where n is the number of elements in the queue. It creates a shallow copy of the internal array. the space required is proportional to the number of elements in the queue.
      */
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `clone()` function returns a new Queue object with the same elements as the original Queue.
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
@@ -267,4 +288,17 @@ export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
      * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
     peek(): E | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * The `clone` function returns a new instance of the `LinkedListQueue` class with the same values as
+     * the current instance.
+     * @returns The `clone()` method is returning a new instance of `LinkedListQueue` with the same
+     * values as the original `LinkedListQueue`.
+     */
+    clone(): LinkedListQueue<E>;
 }

package/dist/data-structures/queue/queue.js

@@ -28,9 +28,17 @@ class Queue extends base_1.IterableElementBase {
                 this.push(el);
         }
     }
+    /**
+     * The elements function returns the elements of this set.
+     * @return An array of the elements in the stack
+     */
     get elements() {
         return this._elements;
     }
+    /**
+     * The offset function returns the offset of the current page.
+     * @return The value of the private variable _offset
+     */
     get offset() {
         return this._offset;
     }
@@ -123,6 +131,24 @@ class Queue extends base_1.IterableElementBase {
         this._offset = 0;
         return first;
     }
+    /**
+     * The delete function removes an element from the list.
+     * @param element: E Specify the element to be deleted
+     * @return A boolean value indicating whether the element was successfully deleted or not
+     */
+    delete(element) {
+        const index = this.elements.indexOf(element);
+        return this.deleteAt(index);
+    }
+    /**
+     * The deleteAt function deletes the element at a given index.
+     * @param index: number Determine the index of the element to be deleted
+     * @return A boolean value
+     */
+    deleteAt(index) {
+        const spliced = this.elements.splice(index, 1);
+        return spliced.length === 1;
+    }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -191,7 +217,7 @@ class Queue extends base_1.IterableElementBase {
      *
      * @param index
      */
-    getAt(index) {
+    at(index) {
         return this.elements[index];
     }
     /**
@@ -230,12 +256,13 @@ class Queue extends base_1.IterableElementBase {
         this._offset = 0;
     }
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * where n is the number of elements in the queue. It creates a shallow copy of the internal array. the space required is proportional to the number of elements in the queue.
      */
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `clone()` function returns a new Queue object with the same elements as the original Queue.
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
@@ -348,5 +375,20 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
     peek() {
         return this.first;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * The `clone` function returns a new instance of the `LinkedListQueue` class with the same values as
+     * the current instance.
+     * @returns The `clone()` method is returning a new instance of `LinkedListQueue` with the same
+     * values as the original `LinkedListQueue`.
+     */
+    clone() {
+        return new LinkedListQueue(this.values());
+    }
 }
 exports.LinkedListQueue = LinkedListQueue;

package/dist/data-structures/stack/stack.d.ts

@@ -24,6 +24,10 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     constructor(elements?: Iterable<E>);
     protected _elements: E[];
+    /**
+     * The elements function returns the elements of this set.
+     * @return An array of elements
+     */
     get elements(): E[];
     /**
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
@@ -87,6 +91,18 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * array is empty, it returns `undefined`.
      */
     pop(): E | undefined;
+    /**
+     * The delete function removes an element from the stack.
+     * @param element: E Specify the element to be deleted
+     * @return A boolean value indicating whether the element was successfully deleted or not
+     */
+    delete(element: E): boolean;
+    /**
+     * The deleteAt function deletes the element at a given index.
+     * @param index: number Determine the index of the element to be deleted
+     * @return A boolean value
+     */
+    deleteAt(index: number): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/stack/stack.js

@@ -25,6 +25,10 @@ class Stack extends base_1.IterableElementBase {
                 this.push(el);
         }
     }
+    /**
+     * The elements function returns the elements of this set.
+     * @return An array of elements
+     */
     get elements() {
         return this._elements;
     }
@@ -107,6 +111,24 @@ class Stack extends base_1.IterableElementBase {
             return;
         return this.elements.pop();
     }
+    /**
+     * The delete function removes an element from the stack.
+     * @param element: E Specify the element to be deleted
+     * @return A boolean value indicating whether the element was successfully deleted or not
+     */
+    delete(element) {
+        const index = this.elements.indexOf(element);
+        return this.deleteAt(index);
+    }
+    /**
+     * The deleteAt function deletes the element at a given index.
+     * @param index: number Determine the index of the element to be deleted
+     * @return A boolean value
+     */
+    deleteAt(index) {
+        const spliced = this.elements.splice(index, 1);
+        return spliced.length === 1;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/trie/trie.d.ts

@@ -30,13 +30,32 @@ export declare class TrieNode {
  * 10. IP Routing: Used in certain types of IP routing algorithms.
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
-export declare class Trie extends IterableElementBase<string> {
+export declare class Trie extends IterableElementBase<string, Trie> {
+    /**
+     * The constructor function for the Trie class.
+     * @param words: Iterable string Initialize the trie with a set of words
+     * @param options?: TrieOptions Allow the user to pass in options for the trie
+     * @return This
+     */
     constructor(words?: Iterable<string>, options?: TrieOptions);
     protected _size: number;
+    /**
+     * The size function returns the size of the stack.
+     * @return The number of elements in the list
+     */
     get size(): number;
     protected _caseSensitive: boolean;
+    /**
+     * The caseSensitive function is a getter that returns the value of the private _caseSensitive property.
+     *
+     * @return The value of the _casesensitive private variable
+     */
     get caseSensitive(): boolean;
     protected _root: TrieNode;
+    /**
+     * The root function returns the root node of the tree.
+     * @return The root node
+     */
     get root(): TrieNode;
     /**
      * Time Complexity: O(M), where M is the length of the word being added.
@@ -64,6 +83,11 @@ export declare class Trie extends IterableElementBase<string> {
      * @returns {boolean} True if the word is present in the Trie.
      */
     has(word: string): boolean;
+    /**
+     * The isEmpty function checks if the size of the queue is 0.
+     * @return True if the size of the queue is 0
+     */
+    isEmpty(): boolean;
     /**
      * Time Complexity: O(M), where M is the length of the word being deleted.
      * Space Complexity: O(M) - Due to the recursive DFS approach.
@@ -154,6 +178,19 @@ export declare class Trie extends IterableElementBase<string> {
      * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function returns a new instance of the Trie class with the same values and case
+     * sensitivity as the original Trie.
+     * @returns A new instance of the Trie class is being returned.
+     */
+    clone(): Trie;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/trie/trie.js

@@ -28,6 +28,12 @@ exports.TrieNode = TrieNode;
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
 class Trie extends base_1.IterableElementBase {
+    /**
+     * The constructor function for the Trie class.
+     * @param words: Iterable string Initialize the trie with a set of words
+     * @param options?: TrieOptions Allow the user to pass in options for the trie
+     * @return This
+     */
     constructor(words = [], options) {
         super();
         this._size = 0;
@@ -43,12 +49,25 @@ class Trie extends base_1.IterableElementBase {
                 this.add(word);
         }
     }
+    /**
+     * The size function returns the size of the stack.
+     * @return The number of elements in the list
+     */
     get size() {
         return this._size;
     }
+    /**
+     * The caseSensitive function is a getter that returns the value of the private _caseSensitive property.
+     *
+     * @return The value of the _casesensitive private variable
+     */
     get caseSensitive() {
         return this._caseSensitive;
     }
+    /**
+     * The root function returns the root node of the tree.
+     * @return The root node
+     */
     get root() {
         return this._root;
     }
@@ -106,6 +125,13 @@ class Trie extends base_1.IterableElementBase {
         }
         return cur.isEnd;
     }
+    /**
+     * The isEmpty function checks if the size of the queue is 0.
+     * @return True if the size of the queue is 0
+     */
+    isEmpty() {
+        return this.size === 0;
+    }
     /**
      * Time Complexity: O(M), where M is the length of the word being deleted.
      * Space Complexity: O(M) - Due to the recursive DFS approach.
@@ -326,6 +352,21 @@ class Trie extends base_1.IterableElementBase {
             dfs(startNode, prefix);
         return words;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function returns a new instance of the Trie class with the same values and case
+     * sensitivity as the original Trie.
+     * @returns A new instance of the Trie class is being returned.
+     */
+    clone() {
+        return new Trie(this.values(), { caseSensitive: this.caseSensitive });
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -1,7 +1,7 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
 import { IterationType } from "../../common";
 export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type BinaryTreeNested<K, V, N extends BinaryTreeNode<K, V, N>> = BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BinaryTreeNested<K, V, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions<K> = {
     iterationType?: IterationType;
     extractor?: (key: K) => number;

package/dist/types/data-structures/hash/hash-map.d.ts

@@ -4,13 +4,14 @@ export type HashMapLinkedNode<K, V> = {
     next: HashMapLinkedNode<K, V>;
     prev: HashMapLinkedNode<K, V>;
 };
-export type LinkedHashMapOptions<K> = {
+export type LinkedHashMapOptions<K, V, R> = {
     hashFn?: (key: K) => string;
     objHashFn?: (key: K) => object;
+    toEntryFn?: (rawElement: R) => [K, V];
 };
-export type HashMapOptions<K, V, T> = {
+export type HashMapOptions<K, V, R> = {
     hashFn?: (key: K) => string;
-    toEntryFn?: (rawElement: T) => [K, V];
+    toEntryFn?: (rawElement: R) => [K, V];
 };
 export type HashMapStoreItem<K, V> = {
     key: K;