min-heap-typed 1.51.7 → 1.51.9

package/dist/data-structures/graph/abstract-graph.js

@@ -397,9 +397,8 @@ class AbstractGraph extends base_1.IterableEntryBase {
     }
     /**
      *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
      */
@@ -525,9 +524,8 @@ class AbstractGraph extends base_1.IterableEntryBase {
      * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edgeMap.
      * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(VO^3), where VO is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
      *
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
      * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
      */
@@ -651,9 +649,8 @@ class AbstractGraph extends base_1.IterableEntryBase {
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
      * one to rest pairs
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
      *
@@ -758,9 +755,8 @@ class AbstractGraph extends base_1.IterableEntryBase {
     }
     /**
      * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
-     * /
-  
-     /**
+     */
+    /**
      * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
      * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
      */
@@ -776,9 +772,8 @@ class AbstractGraph extends base_1.IterableEntryBase {
      * Not support graph with negative weight cycle
      * all pairs
      * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
      * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
      *

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

@@ -8,20 +8,21 @@
 import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem, LinkedHashMapOptions } from '../../types';
 import { IterableEntryBase } from '../base';
 /**
- * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
+ * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key map to a value.
  * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries based on a key.
- * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
+ * 3. Unique Keys: Keys are unique.
+ * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
     /**
      * The constructor function initializes a HashMap object with an optional initial collection and
      * options.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `T`. It is an optional parameter and its default value is an empty array `[]`.
      * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(rawCollection?: Iterable<R | [K, V]>, options?: HashMapOptions<K, V, R>);
+    constructor(entryOrRawElements?: Iterable<R | [K, V]>, options?: HashMapOptions<K, V, R>);
     protected _store: {
         [key: string]: HashMapStoreItem<K, V>;
     };
@@ -40,12 +41,12 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * `object` and values of type `V`.
      */
     get objMap(): Map<object, V>;
-    protected _toEntryFn: (rawElement: R) => [K, V];
+    protected _toEntryFn?: (rawElement: R) => [K, V];
     /**
      * The function returns the value of the _toEntryFn property.
      * @returns The function being returned is `this._toEntryFn`.
      */
-    get toEntryFn(): (rawElement: R) => [K, V];
+    get toEntryFn(): ((rawElement: R) => [K, V]) | undefined;
     protected _size: number;
     /**
      * The function returns the size of an object.
@@ -90,11 +91,11 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
     /**
      * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
      * pair using a mapping function, and sets each key-value pair in the current object.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `T`.
      * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(rawCollection: Iterable<R | [K, V]>): boolean[];
+    setMany(entryOrRawElements: Iterable<R | [K, V]>): boolean[];
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
@@ -205,14 +206,14 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
     /**
      * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements. It is
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements. It is
      * used to initialize the HashMapLinked instance with key-value pairs. Each element in the
-     * `rawCollection` is converted to a key-value pair using the `toEntryFn` function (if provided) and
+     * `entryOrRawElements` is converted to a key-value pair using the `toEntryFn` function (if provided) and
      * then added to the HashMap
      * @param [options] - The `options` parameter is an optional object that can contain the following
      * properties:
      */
-    constructor(rawCollection?: Iterable<R>, options?: LinkedHashMapOptions<K, V, R>);
+    constructor(entryOrRawElements?: Iterable<R>, options?: LinkedHashMapOptions<K, V, R>);
     protected _hashFn: (key: K) => string;
     /**
      * The function returns the hash function used for generating a hash value for a given key.
@@ -243,7 +244,7 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * The function returns the head node of a HashMapLinkedNode.
      * @returns The method `getHead()` is returning a `HashMapLinkedNode` object with key type `K` and
-     * value type `V | undefined`.
+     * a value type `V | undefined`.
      */
     get head(): HashMapLinkedNode<K, V | undefined>;
     protected _tail: HashMapLinkedNode<K, V | undefined>;
@@ -320,11 +321,11 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * The function `setMany` takes an iterable collection, converts each element into a key-value pair
      * using a provided function, and sets each key-value pair in the current object, returning an array
      * of booleans indicating the success of each set operation.
-     * @param rawCollection - The rawCollection parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The entryOrRawElements parameter is an iterable collection of elements of type
      * R.
      * @returns The `setMany` function returns an array of booleans.
      */
-    setMany(rawCollection: Iterable<R>): boolean[];
+    setMany(entryOrRawElements: Iterable<R>): boolean[];
     /**
      * The function checks if a given key exists in a map, using different logic depending on whether the
      * key is a weak key or not.
@@ -353,9 +354,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -370,9 +370,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -386,9 +385,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -401,9 +399,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -422,9 +419,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -448,9 +444,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -469,9 +464,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -509,9 +503,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      * where n is the number of entries in the LinkedHashMap.
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      * where n is the number of entries in the LinkedHashMap.

package/dist/data-structures/hash/hash-map.js

@@ -4,32 +4,24 @@ exports.LinkedHashMap = exports.HashMap = void 0;
 const base_1 = require("../base");
 const utils_1 = require("../../utils");
 /**
- * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
+ * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key map to a value.
  * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries based on a key.
- * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
+ * 3. Unique Keys: Keys are unique.
+ * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 class HashMap extends base_1.IterableEntryBase {
     /**
      * The constructor function initializes a HashMap object with an optional initial collection and
      * options.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `T`. It is an optional parameter and its default value is an empty array `[]`.
      * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(rawCollection = [], options) {
+    constructor(entryOrRawElements = [], options) {
         super();
         this._store = {};
         this._objMap = new Map();
-        this._toEntryFn = (rawElement) => {
-            if (this.isEntry(rawElement)) {
-                // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
-                return rawElement;
-            }
-            else {
-                throw new Error("If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified.");
-            }
-        };
         this._size = 0;
         this._hashFn = (key) => String(key);
         if (options) {
@@ -41,8 +33,8 @@ class HashMap extends base_1.IterableEntryBase {
                 this._toEntryFn = toEntryFn;
             }
         }
-        if (rawCollection) {
-            this.setMany(rawCollection);
+        if (entryOrRawElements) {
+            this.setMany(entryOrRawElements);
         }
     }
     /**
@@ -137,24 +129,25 @@ class HashMap extends base_1.IterableEntryBase {
     /**
      * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
      * pair using a mapping function, and sets each key-value pair in the current object.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
      * `T`.
      * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(rawCollection) {
+    setMany(entryOrRawElements) {
         const results = [];
-        for (const rawEle of rawCollection) {
+        for (const rawEle of entryOrRawElements) {
             let key, value;
             if (this.isEntry(rawEle)) {
                 key = rawEle[0];
                 value = rawEle[1];
             }
-            else {
+            else if (this.toEntryFn) {
                 const item = this.toEntryFn(rawEle);
                 key = item[0];
                 value = item[1];
             }
-            results.push(this.set(key, value));
+            if (key !== undefined && value !== undefined)
+                results.push(this.set(key, value));
         }
         return results;
     }
@@ -347,14 +340,14 @@ exports.HashMap = HashMap;
 class LinkedHashMap extends base_1.IterableEntryBase {
     /**
      * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
-     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements. It is
+     * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements. It is
      * used to initialize the HashMapLinked instance with key-value pairs. Each element in the
-     * `rawCollection` is converted to a key-value pair using the `toEntryFn` function (if provided) and
+     * `entryOrRawElements` is converted to a key-value pair using the `toEntryFn` function (if provided) and
      * then added to the HashMap
      * @param [options] - The `options` parameter is an optional object that can contain the following
      * properties:
      */
-    constructor(rawCollection = [], options) {
+    constructor(entryOrRawElements = [], options) {
         super();
         this._hashFn = (key) => String(key);
         this._objHashFn = (key) => key;
@@ -366,7 +359,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
                 return rawElement;
             }
             else {
-                throw new Error("If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified.");
+                throw new Error("If the provided entryOrRawElements does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified.");
             }
         };
         this._size = 0;
@@ -382,8 +375,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
                 this._toEntryFn = toEntryFn;
             }
         }
-        if (rawCollection) {
-            for (const el of rawCollection) {
+        if (entryOrRawElements) {
+            for (const el of entryOrRawElements) {
                 const [key, value] = this.toEntryFn(el);
                 this.set(key, value);
             }
@@ -422,7 +415,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     /**
      * The function returns the head node of a HashMapLinkedNode.
      * @returns The method `getHead()` is returning a `HashMapLinkedNode` object with key type `K` and
-     * value type `V | undefined`.
+     * a value type `V | undefined`.
      */
     get head() {
         return this._head;
@@ -526,7 +519,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             const hash = this.objHashFn(key);
             node = this.objMap.get(hash);
             if (!node && isNewKey) {
-                // Create new node
+                // Create a new node
                 node = { key: hash, value, prev: this.tail, next: this._sentinel };
                 this.objMap.set(hash, node);
             }
@@ -566,13 +559,13 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      * The function `setMany` takes an iterable collection, converts each element into a key-value pair
      * using a provided function, and sets each key-value pair in the current object, returning an array
      * of booleans indicating the success of each set operation.
-     * @param rawCollection - The rawCollection parameter is an iterable collection of elements of type
+     * @param entryOrRawElements - The entryOrRawElements parameter is an iterable collection of elements of type
      * R.
      * @returns The `setMany` function returns an array of booleans.
      */
-    setMany(rawCollection) {
+    setMany(entryOrRawElements) {
         const results = [];
-        for (const rawEle of rawCollection) {
+        for (const rawEle of entryOrRawElements) {
             const [key, value] = this.toEntryFn(rawEle);
             results.push(this.set(key, value));
         }
@@ -626,9 +619,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -650,9 +642,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -691,9 +682,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -713,9 +703,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -738,9 +727,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -775,9 +763,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -806,9 +793,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -857,9 +843,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      * where n is the number of entries in the LinkedHashMap.
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      * where n is the number of entries in the LinkedHashMap.

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

@@ -57,9 +57,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param elements
      * @param options
      */
-    static heapify<E>(elements: Iterable<E>, options: {
-        comparator: Comparator<E>;
-    }): Heap<E>;
+    static heapify<E>(elements: Iterable<E>, options: HeapOptions<E>): Heap<E>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -435,9 +435,8 @@ export declare class Deque<E> extends IterableElementBase<E> {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *

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

@@ -770,9 +770,8 @@ class Deque extends base_1.IterableElementBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *

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

@@ -64,7 +64,7 @@ export declare class TrieNode {
  * 8. Autocomplete: Providing recommended words or phrases as a user types.
  * 9. Spell Check: Checking the spelling of words.
  * 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."
+ * 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, Trie> {
     /**

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

@@ -73,7 +73,7 @@ exports.TrieNode = TrieNode;
  * 8. Autocomplete: Providing recommended words or phrases as a user types.
  * 9. Spell Check: Checking the spelling of words.
  * 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."
+ * 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 {
     /**

package/dist/interfaces/binary-tree.d.ts

@@ -1,9 +1,9 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, KeyOrNodeOrEntry } from '../types';
-export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
-    createNode(key: K, value?: N['value']): N;
-    createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
-    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
-    addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[];
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, Comparable, KeyOrNodeOrEntry } from '../types';
+export interface IBinaryTree<K extends Comparable, V = any, R = [K, V], NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTreeNested<K, V, R, NODE>> {
+    createNode(key: K, value?: NODE['value']): NODE;
+    createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
+    add(keyOrNodeOrEntryOrRawElement: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
+    addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
+    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<NODE>[];
 }

package/dist/types/common.d.ts

@@ -1,5 +1,4 @@
-export type BSTVariant = 'STANDARD' | 'INVERSE';
-export type CP = 'LT' | 'EQ' | 'GT';
+export type CP = 1 | -1 | 0;
 /**
  * Enum representing different loop types.
  *
@@ -28,7 +27,7 @@ export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
 export type BTNKeyOrNode<K, N> = K | null | undefined | N;
 export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
 export type BTNodePureKeyOrNode<K, N> = K | N;
-export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
+export type BTNPureKeyOrNodeOrEntry<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
 export type BSTNKeyOrNode<K, N> = K | undefined | N;
 export type BinaryTreeDeleteResult<N> = {
     deleted: N | null | undefined;

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

@@ -1,5 +1,6 @@
 import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../data-structures';
 import type { AVLTreeOptions } from './avl-tree';
-export type AVLTreeMultiMapNodeNested<K, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type AVLTreeMultiMapNested<K, V, N extends AVLTreeMultiMapNode<K, V, N>> = AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type AVLTreeMultiMapOptions<K> = AVLTreeOptions<K> & {};
+import { Comparable } from "../../utils";
+export type AVLTreeMultiMapNodeNested<K extends Comparable, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeMultiMapNested<K extends Comparable, V, R, NODE extends AVLTreeMultiMapNode<K, V, NODE>> = AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

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

@@ -1,5 +1,6 @@
 import { AVLTree, AVLTreeNode } from '../../../data-structures';
 import { BSTOptions } from './bst';
-export type AVLTreeNodeNested<K, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type AVLTreeNested<K, V, N extends AVLTreeNode<K, V, N>> = AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type AVLTreeOptions<K> = BSTOptions<K> & {};
+import { Comparable } from "../../utils";
+export type AVLTreeNodeNested<K extends Comparable, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeNested<K extends Comparable, V, R, NODE extends AVLTreeNode<K, V, NODE>> = AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};