linked-list-typed 1.53.6 → 1.53.7

package/dist/data-structures/binary-tree/tree-multi-map.js

@@ -99,7 +99,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
     createTree(options) {
-        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
+        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
@@ -126,7 +126,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
             if (this.isKey(key))
                 return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
         }
-        if (this._toEntryFn) {
+        if (this.isRaw(keyNodeEntryOrRaw)) {
             const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
             const finalValue = value !== null && value !== void 0 ? value : entryValue;
             if (this.isKey(key))

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

@@ -19,7 +19,7 @@ import { IterableElementBase } from '../base';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.
  * @example
  * // Use Heap to sort an array
- * function heapSort(arr: number[]): number[] {
+ *     function heapSort(arr: number[]): number[] {
  *       const heap = new Heap<number>(arr, { comparator: (a, b) => a - b });
  *       const sorted: number[] = [];
  *       while (!heap.isEmpty()) {
@@ -32,7 +32,7 @@ import { IterableElementBase } from '../base';
  *     console.log(heapSort(array)); // [1, 2, 3, 4, 5, 8]
  * @example
  * // Use Heap to solve top k problems
- * function topKElements(arr: number[], k: number): number[] {
+ *     function topKElements(arr: number[], k: number): number[] {
  *       const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap
  *       arr.forEach(num => {
  *         heap.add(num);
@@ -45,7 +45,7 @@ import { IterableElementBase } from '../base';
  *     console.log(topKElements(numbers, 3)); // [15, 10, 5]
  * @example
  * // Use Heap to merge sorted sequences
- * function mergeSortedSequences(sequences: number[][]): number[] {
+ *     function mergeSortedSequences(sequences: number[][]): number[] {
  *       const heap = new Heap<{ value: number; seqIndex: number; itemIndex: number }>([], {
  *         comparator: (a, b) => a.value - b.value // Min heap
  *       });
@@ -82,7 +82,7 @@ import { IterableElementBase } from '../base';
  *     console.log(mergeSortedSequences(sequences)); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
  * @example
  * // Use Heap to dynamically maintain the median
- * class MedianFinder {
+ *     class MedianFinder {
  *       private low: MaxHeap<number>; // Max heap, stores the smaller half
  *       private high: MinHeap<number>; // Min heap, stores the larger half
  *
@@ -119,7 +119,7 @@ import { IterableElementBase } from '../base';
  *     console.log(medianFinder.findMedian()); // 30
  * @example
  * // Use Heap for load balancing
- * function loadBalance(requests: number[], servers: number): number[] {
+ *     function loadBalance(requests: number[], servers: number): number[] {
  *       const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap
  *       const serverLoads = new Array(servers).fill(0);
  *
@@ -141,7 +141,7 @@ import { IterableElementBase } from '../base';
  *     console.log(loadBalance(requests, 3)); // [12, 8, 5]
  * @example
  * // Use Heap to schedule tasks
- * type Task = [string, number];
+ *     type Task = [string, number];
  *
  *     function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {
  *       const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap

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

@@ -21,7 +21,7 @@ const base_1 = require("../base");
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.
  * @example
  * // Use Heap to sort an array
- * function heapSort(arr: number[]): number[] {
+ *     function heapSort(arr: number[]): number[] {
  *       const heap = new Heap<number>(arr, { comparator: (a, b) => a - b });
  *       const sorted: number[] = [];
  *       while (!heap.isEmpty()) {
@@ -34,7 +34,7 @@ const base_1 = require("../base");
  *     console.log(heapSort(array)); // [1, 2, 3, 4, 5, 8]
  * @example
  * // Use Heap to solve top k problems
- * function topKElements(arr: number[], k: number): number[] {
+ *     function topKElements(arr: number[], k: number): number[] {
  *       const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap
  *       arr.forEach(num => {
  *         heap.add(num);
@@ -47,7 +47,7 @@ const base_1 = require("../base");
  *     console.log(topKElements(numbers, 3)); // [15, 10, 5]
  * @example
  * // Use Heap to merge sorted sequences
- * function mergeSortedSequences(sequences: number[][]): number[] {
+ *     function mergeSortedSequences(sequences: number[][]): number[] {
  *       const heap = new Heap<{ value: number; seqIndex: number; itemIndex: number }>([], {
  *         comparator: (a, b) => a.value - b.value // Min heap
  *       });
@@ -84,7 +84,7 @@ const base_1 = require("../base");
  *     console.log(mergeSortedSequences(sequences)); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
  * @example
  * // Use Heap to dynamically maintain the median
- * class MedianFinder {
+ *     class MedianFinder {
  *       private low: MaxHeap<number>; // Max heap, stores the smaller half
  *       private high: MinHeap<number>; // Min heap, stores the larger half
  *
@@ -121,7 +121,7 @@ const base_1 = require("../base");
  *     console.log(medianFinder.findMedian()); // 30
  * @example
  * // Use Heap for load balancing
- * function loadBalance(requests: number[], servers: number): number[] {
+ *     function loadBalance(requests: number[], servers: number): number[] {
  *       const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap
  *       const serverLoads = new Array(servers).fill(0);
  *
@@ -143,7 +143,7 @@ const base_1 = require("../base");
  *     console.log(loadBalance(requests, 3)); // [12, 8, 5]
  * @example
  * // Use Heap to schedule tasks
- * type Task = [string, number];
+ *     type Task = [string, number];
  *
  *     function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {
  *       const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -55,13 +55,13 @@ export declare class DoublyLinkedListNode<E = any> {
     set prev(value: DoublyLinkedListNode<E> | undefined);
 }
 /**
- * 1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
+ *1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
  * 2. Bidirectional Traversal: Unlike singly linked lists, doubly linked lists can be easily traversed forwards or backwards. This makes insertions and deletions in the list more flexible and efficient.
  * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
  * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
  * @example
  * // text editor operation history
- * const actions = [
+ *     const actions = [
  *       { type: 'insert', content: 'first line of text' },
  *       { type: 'insert', content: 'second line of text' },
  *       { type: 'delete', content: 'delete the first line' }
@@ -73,7 +73,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     console.log(editorHistory.last?.type); // 'insert'
  * @example
  * // Browser history
- * const browserHistory = new DoublyLinkedList<string>();
+ *     const browserHistory = new DoublyLinkedList<string>();
  *
  *     browserHistory.push('home page');
  *     browserHistory.push('search page');
@@ -84,7 +84,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     console.log(browserHistory.last); // 'search page'
  * @example
  * // Use DoublyLinkedList to implement music player
- * // Define the Song interface
+ *     // Define the Song interface
  *     interface Song {
  *       title: string;
  *       artist: string;
@@ -209,7 +209,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *  //    ]
  * @example
  * // Use DoublyLinkedList to implement LRU cache
- * interface CacheEntry<K, V> {
+ *     interface CacheEntry<K, V> {
  *       key: K;
  *       value: V;
  *     }
@@ -371,7 +371,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     console.log(cache.isEmpty); // true
  * @example
  * // finding lyrics by timestamp in Coldplay's "Fix You"
- * // Create a DoublyLinkedList to store song lyrics with timestamps
+ *     // Create a DoublyLinkedList to store song lyrics with timestamps
  *     const lyricsList = new DoublyLinkedList<{ time: number; text: string }>();
  *
  *     // Detailed lyrics with precise timestamps (in milliseconds)
@@ -411,7 +411,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     console.log(lateTimeLyric?.text); // 'And I will try to fix you'
  * @example
  * // cpu process schedules
- * class Process {
+ *     class Process {
  *       constructor(
  *         public id: number,
  *         public priority: number
@@ -487,6 +487,16 @@ export declare class DoublyLinkedListNode<E = any> {
  *     console.log(scheduler.listProcesses()); // []
  */
 export declare class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R, DoublyLinkedList<E, R>> {
+    /**
+     * This TypeScript constructor initializes a DoublyLinkedList with optional elements and options.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the constructor is an
+     * iterable collection of elements of type `E` or `R`. It is used to initialize the DoublyLinkedList
+     * with the elements provided in the iterable. If no elements are provided, the default value is an
+     * empty iterable.
+     * @param [options] - The `options` parameter in the constructor is of type
+     * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
+     * configuration options to customize the behavior of the DoublyLinkedList.
+     */
     constructor(elements?: Iterable<E> | Iterable<R>, options?: DoublyLinkedListOptions<E, R>);
     protected _head: DoublyLinkedListNode<E> | undefined;
     /**
@@ -729,7 +739,7 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The `get` method returns the value of the first node in the doubly linked list that
      * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
      */
-    get(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): E | undefined;
+    search(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -64,13 +64,13 @@ class DoublyLinkedListNode {
 }
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
 /**
- * 1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
+ *1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
  * 2. Bidirectional Traversal: Unlike singly linked lists, doubly linked lists can be easily traversed forwards or backwards. This makes insertions and deletions in the list more flexible and efficient.
  * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
  * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
  * @example
  * // text editor operation history
- * const actions = [
+ *     const actions = [
  *       { type: 'insert', content: 'first line of text' },
  *       { type: 'insert', content: 'second line of text' },
  *       { type: 'delete', content: 'delete the first line' }
@@ -82,7 +82,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(editorHistory.last?.type); // 'insert'
  * @example
  * // Browser history
- * const browserHistory = new DoublyLinkedList<string>();
+ *     const browserHistory = new DoublyLinkedList<string>();
  *
  *     browserHistory.push('home page');
  *     browserHistory.push('search page');
@@ -93,7 +93,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(browserHistory.last); // 'search page'
  * @example
  * // Use DoublyLinkedList to implement music player
- * // Define the Song interface
+ *     // Define the Song interface
  *     interface Song {
  *       title: string;
  *       artist: string;
@@ -218,7 +218,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *  //    ]
  * @example
  * // Use DoublyLinkedList to implement LRU cache
- * interface CacheEntry<K, V> {
+ *     interface CacheEntry<K, V> {
  *       key: K;
  *       value: V;
  *     }
@@ -380,7 +380,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(cache.isEmpty); // true
  * @example
  * // finding lyrics by timestamp in Coldplay's "Fix You"
- * // Create a DoublyLinkedList to store song lyrics with timestamps
+ *     // Create a DoublyLinkedList to store song lyrics with timestamps
  *     const lyricsList = new DoublyLinkedList<{ time: number; text: string }>();
  *
  *     // Detailed lyrics with precise timestamps (in milliseconds)
@@ -420,7 +420,7 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(lateTimeLyric?.text); // 'And I will try to fix you'
  * @example
  * // cpu process schedules
- * class Process {
+ *     class Process {
  *       constructor(
  *         public id: number,
  *         public priority: number
@@ -496,6 +496,16 @@ exports.DoublyLinkedListNode = DoublyLinkedListNode;
  *     console.log(scheduler.listProcesses()); // []
  */
 class DoublyLinkedList extends base_1.IterableElementBase {
+    /**
+     * This TypeScript constructor initializes a DoublyLinkedList with optional elements and options.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the constructor is an
+     * iterable collection of elements of type `E` or `R`. It is used to initialize the DoublyLinkedList
+     * with the elements provided in the iterable. If no elements are provided, the default value is an
+     * empty iterable.
+     * @param [options] - The `options` parameter in the constructor is of type
+     * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
+     * configuration options to customize the behavior of the DoublyLinkedList.
+     */
     constructor(elements = [], options) {
         super(options);
         this._head = undefined;
@@ -784,7 +794,9 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * node was not found.
      */
     addBefore(existingElementOrNode, newElementOrNode) {
-        const existingNode = this.getNode(existingElementOrNode);
+        const existingNode = this.isNode(existingElementOrNode)
+            ? existingElementOrNode
+            : this.getNode(existingElementOrNode);
         if (existingNode) {
             const newNode = this._ensureNode(newElementOrNode);
             newNode.prev = existingNode.prev;
@@ -818,7 +830,9 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * was not found in the linked list.
      */
     addAfter(existingElementOrNode, newElementOrNode) {
-        const existingNode = this.getNode(existingElementOrNode);
+        const existingNode = this.isNode(existingElementOrNode)
+            ? existingElementOrNode
+            : this.getNode(existingElementOrNode);
         if (existingNode) {
             const newNode = this._ensureNode(newElementOrNode);
             newNode.next = existingNode.next;
@@ -956,7 +970,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * @returns The `get` method returns the value of the first node in the doubly linked list that
      * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
      */
-    get(elementNodeOrPredicate) {
+    search(elementNodeOrPredicate) {
         const predicate = this._ensurePredicate(elementNodeOrPredicate);
         let current = this.head;
         while (current) {

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -123,7 +123,7 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The `get` method returns the value of the first node in the singly linked list that
      * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
      */
-    get(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): E | undefined;
+    search(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -200,7 +200,7 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * @returns The `get` method returns the value of the first node in the singly linked list that
      * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
      */
-    get(elementNodeOrPredicate) {
+    search(elementNodeOrPredicate) {
         const predicate = this._ensurePredicate(elementNodeOrPredicate);
         let current = this.head;
         while (current) {

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.

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.

package/dist/index.d.ts

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

package/dist/index.js

@@ -24,4 +24,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./data-structures/linked-list"), exports);
 __exportStar(require("./types/data-structures/linked-list"), 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>;