min-heap-typed 1.50.1 → 1.50.3

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

@@ -12,10 +12,46 @@ import { IterableElementBase } from '../base';
  * and a flag indicating whether it's the end of a word.
  */
 export declare class TrieNode {
-    key: string;
-    children: Map<string, TrieNode>;
-    isEnd: boolean;
     constructor(key: string);
+    protected _key: string;
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key(): string;
+    /**
+     * The above function sets the value of a protected variable called "key".
+     * @param {string} value - The value parameter is a string that represents the value to be assigned
+     * to the key.
+     */
+    set key(value: string);
+    protected _children: Map<string, TrieNode>;
+    /**
+     * The function returns the children of a TrieNode as a Map.
+     * @returns The `children` property of the TrieNode object, which is a Map containing string keys and
+     * TrieNode values.
+     */
+    get children(): Map<string, TrieNode>;
+    /**
+     * The function sets the value of the `_children` property of a TrieNode object.
+     * @param value - The value parameter is a Map object that represents the children of a TrieNode. The
+     * keys of the map are strings, which represent the characters that are associated with each child
+     * TrieNode. The values of the map are TrieNode objects, which represent the child nodes of the
+     * current TrieNode.
+     */
+    set children(value: Map<string, TrieNode>);
+    protected _isEnd: boolean;
+    /**
+     * The function returns a boolean value indicating whether a certain condition is met.
+     * @returns The method is returning a boolean value, specifically the value of the variable `_isEnd`.
+     */
+    get isEnd(): boolean;
+    /**
+     * The function sets the value of the "_isEnd" property.
+     * @param {boolean} value - The value parameter is a boolean value that indicates whether the current
+     * state is the end state or not.
+     */
+    set isEnd(value: boolean);
 }
 /**
  * 1. Node Structure: Each node in a Trie represents a string (or a part of a string). The root node typically represents an empty string.
@@ -30,21 +66,39 @@ 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 protected _caseSensitive property.
+     * @return The value of the _caseSensitive protected 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.
-     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     * Time Complexity: O(l), where l is the length of the word being added.
+     * Space Complexity: O(l) - Each character in the word adds a TrieNode.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the word being added.
-     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     * Time Complexity: O(l), where l is the length of the word being added.
+     * Space Complexity: O(l) - Each character in the word adds a TrieNode.
      *
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.
@@ -52,11 +106,11 @@ export declare class Trie extends IterableElementBase<string> {
      */
     add(word: string): boolean;
     /**
-     * Time Complexity: O(M), where M is the length of the input word.
+     * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input word.
+     * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.
      *
      * Check if the Trie contains a given word.
@@ -65,12 +119,35 @@ export declare class Trie extends IterableElementBase<string> {
      */
     has(word: string): 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.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * 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(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the size of the Trie to 0 and creates a new root TrieNode.
+     */
+    clear(): void;
+    /**
+     * Time Complexity: O(l), where l is the length of the word being deleted.
+     * Space Complexity: O(n) - Due to the recursive DFS approach.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the word being deleted.
-     * Space Complexity: O(M) - Due to the recursive DFS approach.
+     * Time Complexity: O(l), where l is the length of the word being deleted.
+     * Space Complexity: O(n) - Due to the recursive DFS approach.
      *
      * Remove a word from the Trie structure.
      * @param{string} word - The word to delete.
@@ -78,21 +155,21 @@ export declare class Trie extends IterableElementBase<string> {
      */
     delete(word: string): boolean;
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
      * Space Complexity: O(1) - Constant space.
      *
      */
     getHeight(): number;
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      *
      * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
@@ -101,11 +178,11 @@ export declare class Trie extends IterableElementBase<string> {
      */
     hasPurePrefix(input: string): boolean;
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      *
      * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
@@ -114,12 +191,12 @@ export declare class Trie extends IterableElementBase<string> {
      */
     hasPrefix(input: string): boolean;
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the input prefix.
      */
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the input prefix.
      *
      * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
      * @param {string} input - The input string representing the common prefix to check for.
@@ -127,24 +204,24 @@ export declare class Trie extends IterableElementBase<string> {
      */
     hasCommonPrefix(input: string): boolean;
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the longest common prefix.
      */
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the longest common prefix.
      *
      * Get the longest common prefix among all the words stored in the Trie.
      * @returns {string} The longest common prefix found in the Trie.
      */
     getLongestCommonPrefix(): string;
     /**
-     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
-     * Space Complexity: O(K * L) - The space required for the output array.
+     * Time Complexity: O(w * l), where w is the number of words retrieved, and l is the average length of the words.
+     * Space Complexity: O(w * l) - The space required for the output array.
      */
     /**
-     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
-     * Space Complexity: O(K * L) - The space required for the output array.
+     * Time Complexity: O(w * l), where w is the number of words retrieved, and l is the average length of the words.
+     * Space Complexity: O(w * l) - The space required for the output array.
      *
      * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
@@ -154,6 +231,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)
@@ -191,13 +281,24 @@ export declare class Trie extends IterableElementBase<string> {
      * @returns The `map` function is returning a new Trie object.
      */
     map(callback: ElementCallback<string, string>, thisArg?: any): Trie;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `_getIterator` returns an iterable iterator that performs a depth-first search on a
+     * trie data structure and yields all the paths to the end nodes.
+     */
     protected _getIterator(): IterableIterator<string>;
     /**
-     * Time Complexity: O(M), where M is the length of the input string.
+     * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input string.
+     * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.
      *
      * @param str

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

@@ -8,9 +8,57 @@ const base_1 = require("../base");
  */
 class TrieNode {
     constructor(key) {
-        this.key = key;
-        this.isEnd = false;
-        this.children = new Map();
+        this._key = key;
+        this._isEnd = false;
+        this._children = new Map();
+    }
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key() {
+        return this._key;
+    }
+    /**
+     * The above function sets the value of a protected variable called "key".
+     * @param {string} value - The value parameter is a string that represents the value to be assigned
+     * to the key.
+     */
+    set key(value) {
+        this._key = value;
+    }
+    /**
+     * The function returns the children of a TrieNode as a Map.
+     * @returns The `children` property of the TrieNode object, which is a Map containing string keys and
+     * TrieNode values.
+     */
+    get children() {
+        return this._children;
+    }
+    /**
+     * The function sets the value of the `_children` property of a TrieNode object.
+     * @param value - The value parameter is a Map object that represents the children of a TrieNode. The
+     * keys of the map are strings, which represent the characters that are associated with each child
+     * TrieNode. The values of the map are TrieNode objects, which represent the child nodes of the
+     * current TrieNode.
+     */
+    set children(value) {
+        this._children = value;
+    }
+    /**
+     * The function returns a boolean value indicating whether a certain condition is met.
+     * @returns The method is returning a boolean value, specifically the value of the variable `_isEnd`.
+     */
+    get isEnd() {
+        return this._isEnd;
+    }
+    /**
+     * The function sets the value of the "_isEnd" property.
+     * @param {boolean} value - The value parameter is a boolean value that indicates whether the current
+     * state is the end state or not.
+     */
+    set isEnd(value) {
+        this._isEnd = value;
     }
 }
 exports.TrieNode = TrieNode;
@@ -28,6 +76,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,22 +97,34 @@ 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 protected _caseSensitive property.
+     * @return The value of the _caseSensitive protected 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;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the word being added.
-     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     * Time Complexity: O(l), where l is the length of the word being added.
+     * Space Complexity: O(l) - Each character in the word adds a TrieNode.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the word being added.
-     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     * Time Complexity: O(l), where l is the length of the word being added.
+     * Space Complexity: O(l) - Each character in the word adds a TrieNode.
      *
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.
@@ -84,11 +150,11 @@ class Trie extends base_1.IterableElementBase {
         return isNewWord;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the input word.
+     * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input word.
+     * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.
      *
      * Check if the Trie contains a given word.
@@ -107,12 +173,40 @@ class Trie extends base_1.IterableElementBase {
         return cur.isEnd;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the word being deleted.
-     * Space Complexity: O(M) - Due to the recursive DFS approach.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(M), where M is the length of the word being deleted.
-     * Space Complexity: O(M) - Due to the recursive DFS approach.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * 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(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the size of the Trie to 0 and creates a new root TrieNode.
+     */
+    clear() {
+        this._size = 0;
+        this._root = new TrieNode('');
+    }
+    /**
+     * Time Complexity: O(l), where l is the length of the word being deleted.
+     * Space Complexity: O(n) - Due to the recursive DFS approach.
+     */
+    /**
+     * Time Complexity: O(l), where l is the length of the word being deleted.
+     * Space Complexity: O(n) - Due to the recursive DFS approach.
      *
      * Remove a word from the Trie structure.
      * @param{string} word - The word to delete.
@@ -154,11 +248,11 @@ class Trie extends base_1.IterableElementBase {
         return isDeleted;
     }
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
      * Space Complexity: O(1) - Constant space.
      *
      */
@@ -182,11 +276,11 @@ class Trie extends base_1.IterableElementBase {
         return maxDepth;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      *
      * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
@@ -205,11 +299,11 @@ class Trie extends base_1.IterableElementBase {
         return !cur.isEnd;
     }
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(l), where l is the length of the input prefix.
      * Space Complexity: O(1) - Constant space.
      *
      * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
@@ -228,12 +322,12 @@ class Trie extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the input prefix.
      */
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the input prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the input prefix.
      *
      * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
      * @param {string} input - The input string representing the common prefix to check for.
@@ -257,12 +351,12 @@ class Trie extends base_1.IterableElementBase {
         return commonPre === input;
     }
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the longest common prefix.
      */
     /**
-     * Time Complexity: O(N), where N is the total number of nodes in the trie.
-     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     * Time Complexity: O(n), where n is the total number of nodes in the trie.
+     * Space Complexity: O(l), where l is the length of the longest common prefix.
      *
      * Get the longest common prefix among all the words stored in the Trie.
      * @returns {string} The longest common prefix found in the Trie.
@@ -282,12 +376,12 @@ class Trie extends base_1.IterableElementBase {
         return commonPre;
     }
     /**
-     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
-     * Space Complexity: O(K * L) - The space required for the output array.
+     * Time Complexity: O(w * l), where w is the number of words retrieved, and l is the average length of the words.
+     * Space Complexity: O(w * l) - The space required for the output array.
      */
     /**
-     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
-     * Space Complexity: O(K * L) - The space required for the output array.
+     * Time Complexity: O(w * l), where w is the number of words retrieved, and l is the average length of the words.
+     * Space Complexity: O(w * l) - The space required for the output array.
      *
      * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
@@ -326,6 +420,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)
@@ -381,6 +490,17 @@ class Trie extends base_1.IterableElementBase {
         }
         return newTrie;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `_getIterator` returns an iterable iterator that performs a depth-first search on a
+     * trie data structure and yields all the paths to the end nodes.
+     */
     *_getIterator() {
         function* _dfs(node, path) {
             if (node.isEnd) {
@@ -393,11 +513,11 @@ class Trie extends base_1.IterableElementBase {
         yield* _dfs(this.root, '');
     }
     /**
-     * Time Complexity: O(M), where M is the length of the input string.
+     * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.
      */
     /**
-     * Time Complexity: O(M), where M is the length of the input string.
+     * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.
      *
      * @param str

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;

package/dist/types/utils/utils.d.ts

@@ -5,3 +5,4 @@ export type Thunk = () => ReturnType<ToThunkFn> & {
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type Any = string | number | boolean | object | null | undefined | symbol;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.50.1",
+  "version": "1.50.3",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -132,6 +132,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.50.0"
+    "data-structure-typed": "^1.50.3"
   }
 }