data-structure-typed 1.50.0 → 1.50.2

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

@@ -14,6 +14,17 @@ export class Deque extends IterableElementBase {
     _lastInBucket = 0;
     _bucketCount = 0;
     _bucketSize = 1 << 12;
+    /**
+     * 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();
         if (options) {
@@ -45,11 +56,28 @@ export class Deque extends IterableElementBase {
             this.push(element);
         }
     }
+    /**
+     * The bucketSize function returns the size of the bucket.
+     *
+     * @return The size of the bucket
+     */
+    get bucketSize() {
+        return this._bucketSize;
+    }
     _buckets = [];
+    /**
+     * The buckets function returns the buckets property of the object.
+     *
+     * @return The buckets property
+     */
     get buckets() {
         return this._buckets;
     }
     _size = 0;
+    /**
+     * The size function returns the number of items in the stack.
+     * @return The number of values in the set
+     */
     get size() {
         return this._size;
     }
@@ -63,6 +91,10 @@ export class Deque extends 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;
@@ -223,7 +255,7 @@ export class Deque extends IterableElementBase {
     *begin() {
         let index = 0;
         while (index < this.size) {
-            yield this.getAt(index);
+            yield this.at(index);
             index++;
         }
     }
@@ -234,7 +266,7 @@ export class Deque extends IterableElementBase {
     *reverseBegin() {
         let index = this.size - 1;
         while (index >= 0) {
-            yield this.getAt(index);
+            yield this.at(index);
             index--;
         }
     }
@@ -246,13 +278,13 @@ export class Deque extends 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) {
         rangeCheck(pos, 0, this.size - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         return this._buckets[bucketIndex][indexInBucket];
@@ -310,9 +342,9 @@ export class Deque extends 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)
@@ -332,18 +364,48 @@ export class Deque extends 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)
@@ -400,14 +462,14 @@ export class Deque extends 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;
     }
     /**
@@ -451,15 +513,15 @@ export class Deque extends 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;
     }
     /**
@@ -479,7 +541,7 @@ export class Deque extends 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) {
@@ -523,30 +585,6 @@ export class Deque extends 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)
@@ -564,7 +602,7 @@ export class Deque extends IterableElementBase {
      */
     indexOf(element) {
         for (let i = 0; i < this.size; ++i) {
-            if (this.getAt(i) === element) {
+            if (this.at(i) === element) {
                 return i;
             }
         }
@@ -584,6 +622,22 @@ export class Deque extends 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)
@@ -701,7 +755,7 @@ export class Deque extends IterableElementBase {
      */
     *_getIterator() {
         for (let i = 0; i < this.size; ++i) {
-            yield this.getAt(i);
+            yield this.at(i);
         }
     }
     /**

package/dist/mjs/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/mjs/data-structures/queue/queue.js

@@ -24,10 +24,18 @@ export class Queue extends IterableElementBase {
         }
     }
     _elements = [];
+    /**
+     * The elements function returns the elements of this set.
+     * @return An array of the elements in the stack
+     */
     get elements() {
         return this._elements;
     }
     _offset = 0;
+    /**
+     * The offset function returns the offset of the current page.
+     * @return The value of the private variable _offset
+     */
     get offset() {
         return this._offset;
     }
@@ -120,6 +128,24 @@ export class Queue extends 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.
@@ -188,7 +214,7 @@ export class Queue extends IterableElementBase {
      *
      * @param index
      */
-    getAt(index) {
+    at(index) {
         return this.elements[index];
     }
     /**
@@ -227,12 +253,13 @@ export class Queue extends 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.
@@ -343,4 +370,19 @@ export class LinkedListQueue extends 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());
+    }
 }

package/dist/mjs/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/mjs/data-structures/stack/stack.js

@@ -22,6 +22,10 @@ export class Stack extends IterableElementBase {
         }
     }
     _elements = [];
+    /**
+     * The elements function returns the elements of this set.
+     * @return An array of elements
+     */
     get elements() {
         return this._elements;
     }
@@ -104,6 +108,24 @@ export class Stack extends 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/mjs/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/mjs/data-structures/trie/trie.js

@@ -27,6 +27,12 @@ export class TrieNode {
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
 export class Trie extends 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();
         if (options) {
@@ -40,14 +46,27 @@ export class Trie extends IterableElementBase {
         }
     }
     _size = 0;
+    /**
+     * The size function returns the size of the stack.
+     * @return The number of elements in the list
+     */
     get size() {
         return this._size;
     }
     _caseSensitive = true;
+    /**
+     * 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;
     }
     _root = new TrieNode('');
+    /**
+     * The root function returns the root node of the tree.
+     * @return The root node
+     */
     get root() {
         return this._root;
     }
@@ -105,6 +124,13 @@ export class Trie extends 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.
@@ -325,6 +351,21 @@ export class Trie extends 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/mjs/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;