stack-typed 1.53.6 → 1.53.8

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

@@ -22,14 +22,7 @@ class Queue extends base_1.IterableElementBase {
             const { autoCompactRatio = 0.5 } = options;
             this._autoCompactRatio = autoCompactRatio;
         }
-        if (elements) {
-            for (const el of elements) {
-                if (this.toElementFn)
-                    this.push(this.toElementFn(el));
-                else
-                    this.push(el);
-            }
-        }
+        this.pushMany(elements);
     }
     /**
      * The elements function returns the elements of this set.
@@ -114,6 +107,27 @@ class Queue extends base_1.IterableElementBase {
         this.elements.push(element);
         return true;
     }
+    /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
+     * The `pushMany` function iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `pushMany` function
+     * is an iterable containing elements of type `E` or `R`.
+     * @returns The `pushMany` function is returning an array of boolean values indicating whether each
+     * element was successfully pushed into the data structure.
+     */
+    pushMany(elements) {
+        const ans = [];
+        for (const el of elements) {
+            if (this.toElementFn)
+                ans.push(this.push(this.toElementFn(el)));
+            else
+                ans.push(this.push(el));
+        }
+        return ans;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -132,6 +146,9 @@ class Queue extends base_1.IterableElementBase {
         return first;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The delete function removes an element from the list.
      * @param {E} element - Specify the element to be deleted
      * @return A boolean value indicating whether the element was successfully deleted or not
@@ -141,6 +158,9 @@ class Queue extends base_1.IterableElementBase {
         return this.deleteAt(index);
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The deleteAt function deletes the element at a given index.
      * @param {number} index - Determine the index of the element to be deleted
      * @return A boolean value
@@ -153,7 +173,12 @@ class Queue extends base_1.IterableElementBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * @param index
+     * The `at` function returns the element at a specified index adjusted by an offset, or `undefined`
+     * if the index is out of bounds.
+     * @param {number} index - The `index` parameter represents the position of the element you want to
+     * retrieve from the data structure.
+     * @returns The `at` method is returning the element at the specified index adjusted by the offset
+     * `_offset`.
      */
     at(index) {
         return this.elements[index + this._offset];
@@ -189,6 +214,9 @@ class Queue extends base_1.IterableElementBase {
         this._offset = 0;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * The `compact` function in TypeScript slices the elements array based on the offset and resets the
      * offset to zero.
      * @returns The `compact()` method is returning a boolean value of `true`.
@@ -238,6 +266,20 @@ class Queue extends base_1.IterableElementBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new Queue by applying a callback function to each
+     * element in the original Queue.
+     * @param callback - The `callback` parameter is a function that will be applied to each element in
+     * the queue. It takes the current element, its index, and the queue itself as arguments, and returns
+     * a new element.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be provided to
+     * convert a raw element of type `RM` to a new element of type `EM`. This function is used within the
+     * `map` method to transform each raw element before passing it to the `callback` function. If
+     * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is used to specify the
+     * value of `this` when executing the `callback` function. It allows you to set the context (the
+     * value of `this`) within the callback function. If `thisArg` is provided, it will be
+     * @returns A new Queue object containing elements of type EM, which are the result of applying the
+     * callback function to each element in the original Queue object.
      */
     map(callback, toElementFn, thisArg) {
         const newDeque = new Queue([], { toElementFn });

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

@@ -28,10 +28,6 @@ export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, S
      * @returns The size of the elements array.
      */
     get size(): number;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -43,6 +39,9 @@ export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, S
      */
     static fromArray<E>(elements: E[]): Stack<E>;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if an array is empty and returns a boolean value.
      * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
@@ -74,15 +73,33 @@ export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, S
      */
     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
+     * Time Complexity: O(k)
+     * Space Complexity: O(1)
+     *
+     * The function `pushMany` iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `pushMany` function
+     * is an iterable containing elements of type `E` or `R`. The function iterates over each element in
+     * the iterable and pushes it into the data structure. If a transformation function `toElementFn` is
+     * provided, it is used to
+     * @returns The `pushMany` function is returning an array of boolean values indicating whether each
+     * element was successfully pushed into the data structure.
+     */
+    pushMany(elements: Iterable<E> | Iterable<R>): boolean[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type E.
      */
     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
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type E.
      */
     deleteAt(index: number): boolean;
     /**

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

@@ -14,16 +14,7 @@ class Stack extends base_1.IterableElementBase {
     constructor(elements = [], options) {
         super(options);
         this._elements = [];
-        if (elements) {
-            for (const el of elements) {
-                if (this.toElementFn) {
-                    this.push(this.toElementFn(el));
-                }
-                else {
-                    this.push(el);
-                }
-            }
-        }
+        this.pushMany(elements);
     }
     /**
      * The elements function returns the elements of this set.
@@ -39,10 +30,6 @@ class Stack extends base_1.IterableElementBase {
     get size() {
         return this.elements.length;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -56,6 +43,9 @@ class Stack extends base_1.IterableElementBase {
         return new Stack(elements);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if an array is empty and returns a boolean value.
      * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
@@ -100,18 +90,47 @@ class Stack extends base_1.IterableElementBase {
         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
+     * Time Complexity: O(k)
+     * Space Complexity: O(1)
+     *
+     * The function `pushMany` iterates over elements and pushes them into an array after applying a
+     * transformation function if provided.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `pushMany` function
+     * is an iterable containing elements of type `E` or `R`. The function iterates over each element in
+     * the iterable and pushes it into the data structure. If a transformation function `toElementFn` is
+     * provided, it is used to
+     * @returns The `pushMany` function is returning an array of boolean values indicating whether each
+     * element was successfully pushed into the data structure.
+     */
+    pushMany(elements) {
+        const ans = [];
+        for (const el of elements) {
+            if (this.toElementFn) {
+                ans.push(this.push(this.toElementFn(el)));
+            }
+            else {
+                ans.push(this.push(el));
+            }
+        }
+        return ans;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type E.
      */
     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
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type E.
      */
     deleteAt(index) {
         const spliced = this.elements.splice(index, 1);

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

@@ -65,13 +65,100 @@ export declare class TrieNode {
  * 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.
+ * @example
+ * // Autocomplete: Prefix validation and checking
+ *     const autocomplete = new Trie<string>(['gmail.com', 'gmail.co.nz', 'gmail.co.jp', 'yahoo.com', 'outlook.com']);
+ *
+ *     // Get all completions for a prefix
+ *     const gmailCompletions = autocomplete.getWords('gmail');
+ *     console.log(gmailCompletions); // ['gmail.com', 'gmail.co.nz', 'gmail.co.jp']
+ * @example
+ * // File System Path Operations
+ *     const fileSystem = new Trie<string>([
+ *       '/home/user/documents/file1.txt',
+ *       '/home/user/documents/file2.txt',
+ *       '/home/user/pictures/photo.jpg',
+ *       '/home/user/pictures/vacation/',
+ *       '/home/user/downloads'
+ *     ]);
+ *
+ *     // Find common directory prefix
+ *     console.log(fileSystem.getLongestCommonPrefix()); // '/home/user/'
+ *
+ *     // List all files in a directory
+ *     const documentsFiles = fileSystem.getWords('/home/user/documents/');
+ *     console.log(documentsFiles); // ['/home/user/documents/file1.txt', '/home/user/documents/file2.txt']
+ * @example
+ * // Autocomplete: Basic word suggestions
+ *     // Create a trie for autocomplete
+ *     const autocomplete = new Trie<string>([
+ *       'function',
+ *       'functional',
+ *       'functions',
+ *       'class',
+ *       'classes',
+ *       'classical',
+ *       'closure',
+ *       'const',
+ *       'constructor'
+ *     ]);
+ *
+ *     // Test autocomplete with different prefixes
+ *     console.log(autocomplete.getWords('fun')); // ['functional', 'functions', 'function']
+ *     console.log(autocomplete.getWords('cla')); // ['classes', 'classical', 'class']
+ *     console.log(autocomplete.getWords('con')); // ['constructor', 'const']
+ *
+ *     // Test with non-matching prefix
+ *     console.log(autocomplete.getWords('xyz')); // []
+ * @example
+ * // Dictionary: Case-insensitive word lookup
+ *     // Create a case-insensitive dictionary
+ *     const dictionary = new Trie<string>([], { caseSensitive: false });
+ *
+ *     // Add words with mixed casing
+ *     dictionary.add('Hello');
+ *     dictionary.add('WORLD');
+ *     dictionary.add('JavaScript');
+ *
+ *     // Test lookups with different casings
+ *     console.log(dictionary.has('hello')); // true
+ *     console.log(dictionary.has('HELLO')); // true
+ *     console.log(dictionary.has('Hello')); // true
+ *     console.log(dictionary.has('javascript')); // true
+ *     console.log(dictionary.has('JAVASCRIPT')); // true
+ * @example
+ * // IP Address Routing Table
+ *     // Add IP address prefixes and their corresponding routes
+ *     const routes = {
+ *       '192.168.1': 'LAN_SUBNET_1',
+ *       '192.168.2': 'LAN_SUBNET_2',
+ *       '10.0.0': 'PRIVATE_NETWORK_1',
+ *       '10.0.1': 'PRIVATE_NETWORK_2'
+ *     };
+ *
+ *     const ipRoutingTable = new Trie<string>(Object.keys(routes));
+ *
+ *     // Check IP address prefix matching
+ *     console.log(ipRoutingTable.hasPrefix('192.168.1')); // true
+ *     console.log(ipRoutingTable.hasPrefix('192.168.2')); // true
+ *
+ *     // Validate IP address belongs to subnet
+ *     const ip = '192.168.1.100';
+ *     const subnet = ip.split('.').slice(0, 3).join('.');
+ *     console.log(ipRoutingTable.hasPrefix(subnet)); // true
  */
 export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
     /**
-     * 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
+     * The constructor initializes a Trie data structure with optional options and words provided as
+     * input.
+     * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the constructor is an
+     * iterable containing either strings or elements of type `R`. It is used to initialize the Trie with
+     * a list of words or elements. If no `words` are provided, an empty iterable is used as the default
+     * value.
+     * @param [options] - The `options` parameter in the constructor is an optional object that can
+     * contain configuration options for the Trie data structure. One of the options it can have is
+     * `caseSensitive`, which is a boolean value indicating whether the Trie should be case-sensitive or
+     * not. If `caseSensitive` is set to `
      */
     constructor(words?: Iterable<string> | Iterable<R>, options?: TrieOptions<R>);
     protected _size: number;
@@ -101,6 +188,19 @@ export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R
      * @returns {boolean} True if the word was successfully added.
      */
     add(word: string): boolean;
+    /**
+     * Time Complexity: O(n * l)
+     * Space Complexity: O(1)
+     *
+     * The `addMany` function in TypeScript takes an iterable of strings or elements of type R, converts
+     * them using a provided function if available, and adds them to a data structure while returning an
+     * array of boolean values indicating success.
+     * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the `addMany` function is
+     * an iterable that contains either strings or elements of type `R`.
+     * @returns The `addMany` method returns an array of boolean values indicating whether each word in
+     * the input iterable was successfully added to the data structure.
+     */
+    addMany(words: Iterable<string> | Iterable<R>): boolean[];
     /**
      * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.
@@ -135,9 +235,14 @@ export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R
      */
     delete(word: string): boolean;
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
+     * The function `getHeight` calculates the height of a trie data structure starting from the root
+     * node.
+     * @returns The `getHeight` method returns the maximum depth or height of the trie tree starting from
+     * the root node. It calculates the depth using a breadth-first search (BFS) traversal of the trie
+     * tree and returns the maximum depth found.
      */
     getHeight(): number;
     /**

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

@@ -74,13 +74,100 @@ exports.TrieNode = TrieNode;
  * 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.
+ * @example
+ * // Autocomplete: Prefix validation and checking
+ *     const autocomplete = new Trie<string>(['gmail.com', 'gmail.co.nz', 'gmail.co.jp', 'yahoo.com', 'outlook.com']);
+ *
+ *     // Get all completions for a prefix
+ *     const gmailCompletions = autocomplete.getWords('gmail');
+ *     console.log(gmailCompletions); // ['gmail.com', 'gmail.co.nz', 'gmail.co.jp']
+ * @example
+ * // File System Path Operations
+ *     const fileSystem = new Trie<string>([
+ *       '/home/user/documents/file1.txt',
+ *       '/home/user/documents/file2.txt',
+ *       '/home/user/pictures/photo.jpg',
+ *       '/home/user/pictures/vacation/',
+ *       '/home/user/downloads'
+ *     ]);
+ *
+ *     // Find common directory prefix
+ *     console.log(fileSystem.getLongestCommonPrefix()); // '/home/user/'
+ *
+ *     // List all files in a directory
+ *     const documentsFiles = fileSystem.getWords('/home/user/documents/');
+ *     console.log(documentsFiles); // ['/home/user/documents/file1.txt', '/home/user/documents/file2.txt']
+ * @example
+ * // Autocomplete: Basic word suggestions
+ *     // Create a trie for autocomplete
+ *     const autocomplete = new Trie<string>([
+ *       'function',
+ *       'functional',
+ *       'functions',
+ *       'class',
+ *       'classes',
+ *       'classical',
+ *       'closure',
+ *       'const',
+ *       'constructor'
+ *     ]);
+ *
+ *     // Test autocomplete with different prefixes
+ *     console.log(autocomplete.getWords('fun')); // ['functional', 'functions', 'function']
+ *     console.log(autocomplete.getWords('cla')); // ['classes', 'classical', 'class']
+ *     console.log(autocomplete.getWords('con')); // ['constructor', 'const']
+ *
+ *     // Test with non-matching prefix
+ *     console.log(autocomplete.getWords('xyz')); // []
+ * @example
+ * // Dictionary: Case-insensitive word lookup
+ *     // Create a case-insensitive dictionary
+ *     const dictionary = new Trie<string>([], { caseSensitive: false });
+ *
+ *     // Add words with mixed casing
+ *     dictionary.add('Hello');
+ *     dictionary.add('WORLD');
+ *     dictionary.add('JavaScript');
+ *
+ *     // Test lookups with different casings
+ *     console.log(dictionary.has('hello')); // true
+ *     console.log(dictionary.has('HELLO')); // true
+ *     console.log(dictionary.has('Hello')); // true
+ *     console.log(dictionary.has('javascript')); // true
+ *     console.log(dictionary.has('JAVASCRIPT')); // true
+ * @example
+ * // IP Address Routing Table
+ *     // Add IP address prefixes and their corresponding routes
+ *     const routes = {
+ *       '192.168.1': 'LAN_SUBNET_1',
+ *       '192.168.2': 'LAN_SUBNET_2',
+ *       '10.0.0': 'PRIVATE_NETWORK_1',
+ *       '10.0.1': 'PRIVATE_NETWORK_2'
+ *     };
+ *
+ *     const ipRoutingTable = new Trie<string>(Object.keys(routes));
+ *
+ *     // Check IP address prefix matching
+ *     console.log(ipRoutingTable.hasPrefix('192.168.1')); // true
+ *     console.log(ipRoutingTable.hasPrefix('192.168.2')); // true
+ *
+ *     // Validate IP address belongs to subnet
+ *     const ip = '192.168.1.100';
+ *     const subnet = ip.split('.').slice(0, 3).join('.');
+ *     console.log(ipRoutingTable.hasPrefix(subnet)); // true
  */
 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
+     * The constructor initializes a Trie data structure with optional options and words provided as
+     * input.
+     * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the constructor is an
+     * iterable containing either strings or elements of type `R`. It is used to initialize the Trie with
+     * a list of words or elements. If no `words` are provided, an empty iterable is used as the default
+     * value.
+     * @param [options] - The `options` parameter in the constructor is an optional object that can
+     * contain configuration options for the Trie data structure. One of the options it can have is
+     * `caseSensitive`, which is a boolean value indicating whether the Trie should be case-sensitive or
+     * not. If `caseSensitive` is set to `
      */
     constructor(words = [], options) {
         super(options);
@@ -93,14 +180,7 @@ class Trie extends base_1.IterableElementBase {
                 this._caseSensitive = caseSensitive;
         }
         if (words) {
-            for (const word of words) {
-                if (this.toElementFn) {
-                    this.add(this.toElementFn(word));
-                }
-                else {
-                    this.add(word);
-                }
-            }
+            this.addMany(words);
         }
     }
     /**
@@ -151,6 +231,30 @@ class Trie extends base_1.IterableElementBase {
         }
         return isNewWord;
     }
+    /**
+     * Time Complexity: O(n * l)
+     * Space Complexity: O(1)
+     *
+     * The `addMany` function in TypeScript takes an iterable of strings or elements of type R, converts
+     * them using a provided function if available, and adds them to a data structure while returning an
+     * array of boolean values indicating success.
+     * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the `addMany` function is
+     * an iterable that contains either strings or elements of type `R`.
+     * @returns The `addMany` method returns an array of boolean values indicating whether each word in
+     * the input iterable was successfully added to the data structure.
+     */
+    addMany(words) {
+        const ans = [];
+        for (const word of words) {
+            if (this.toElementFn) {
+                ans.push(this.add(this.toElementFn(word)));
+            }
+            else {
+                ans.push(this.add(word));
+            }
+        }
+        return ans;
+    }
     /**
      * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.
@@ -234,9 +338,14 @@ class Trie extends base_1.IterableElementBase {
         return isDeleted;
     }
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
+     * The function `getHeight` calculates the height of a trie data structure starting from the root
+     * node.
+     * @returns The `getHeight` method returns the maximum depth or height of the trie tree starting from
+     * the root node. It calculates the depth using a breadth-first search (BFS) traversal of the trie
+     * tree and returns the maximum depth found.
      */
     getHeight() {
         const startNode = this.root;

package/dist/index.d.ts

@@ -8,4 +8,5 @@
 export * from './data-structures/stack';
 export * from './types/data-structures/stack';
 export * from './types/common';
-export * from './constants';
+export * from './types/utils';
+export * from './common';

package/dist/index.js

@@ -25,4 +25,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./data-structures/stack"), exports);
 __exportStar(require("./types/data-structures/stack"), exports);
 __exportStar(require("./types/common"), exports);
-__exportStar(require("./constants"), exports);
+__exportStar(require("./types/utils"), exports);
+__exportStar(require("./common"), exports);

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

@@ -1,6 +1,6 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
 import { IterationType, OptValue } from '../../common';
-import { DFSOperation } from '../../../constants';
+import { DFSOperation } 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, R, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;

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

@@ -1,10 +1,11 @@
 import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
-import { Comparator } from '../../common';
+import { Comparable } from '../../utils';
 export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
-    comparator?: Comparator<K>;
+    extractComparable?: (key: K) => Comparable;
+    isReverse?: boolean;
 };
 export type BSTNOptKey<K> = K | undefined;
 export type OptNode<NODE> = NODE | undefined;

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

@@ -3,4 +3,4 @@ import type { BSTOptions } from "./bst";
 export type RBTNColor = 'RED' | 'BLACK';
 export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RedBlackTreeNested<K, V, R, NODE extends RedBlackTreeNode<K, V, NODE>> = RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type RBTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};
+export type RBTreeOptions<K, V, R> = Omit<BSTOptions<K, V, R>, 'isReverse'> & {};

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

@@ -6,13 +6,17 @@ export type TrlFn<A extends any[] = any[], R = any> = (...args: A) => R;
 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 | bigint | boolean | symbol | undefined | object;
+export type Arithmetic = number | bigint;
 export type ComparablePrimitive = number | bigint | string | boolean;
-export type ComparableObject = {
-    [key in string]: any;
-} & ({
-    valueOf: () => ComparablePrimitive | ComparableObject;
+export interface BaseComparableObject {
+    [key: string]: unknown;
+}
+export interface ValueComparableObject extends BaseComparableObject {
+    valueOf: () => ComparablePrimitive | ValueComparableObject;
     toString?: () => string;
-} | {
+}
+export interface StringComparableObject extends BaseComparableObject {
     toString: () => string;
-});
+}
+export type ComparableObject = ValueComparableObject | StringComparableObject;
 export type Comparable = ComparablePrimitive | Date | ComparableObject;