undirected-graph-typed 1.51.9 → 1.52.2

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

@@ -3,7 +3,7 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-import type { ElementCallback } from '../../types';
+import type { ElementCallback, QueueOptions } from '../../types';
 import { IterableElementBase } from '../base';
 import { SinglyLinkedList } from '../linked-list';
 /**
@@ -15,14 +15,8 @@ import { SinglyLinkedList } from '../linked-list';
  * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store elements that are to be visited.
  * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
  */
-export declare class Queue<E = any> extends IterableElementBase<E> {
-    /**
-     * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
-     * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
-     * will be used to initialize the `_elements` property of the class. If not provided, the `_elements` property will be
-     * initialized as an empty array.
-     */
-    constructor(elements?: Iterable<E>);
+export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E, R>> {
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: QueueOptions<E, R>);
     protected _elements: E[];
     /**
      * The elements function returns the elements of this set.
@@ -66,6 +60,18 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * array is empty, it returns `undefined`.
      */
     get last(): E | undefined;
+    _autoCompactRatio: number;
+    /**
+     * This function returns the value of the autoCompactRatio property.
+     * @returns The `autoCompactRatio` property of the object, which is a number.
+     */
+    get autoCompactRatio(): number;
+    /**
+     * The above function sets the autoCompactRatio property to a specified number in TypeScript.
+     * @param {number} v - The parameter `v` represents the value that will be assigned to the
+     * `_autoCompactRatio` property.
+     */
+    set autoCompactRatio(v: number);
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -76,7 +82,6 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      *
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
-     * @static
      * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
      * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
      * array.
@@ -166,6 +171,12 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * The clear function resets the elements array and offset to their initial values.
      */
     clear(): void;
+    /**
+     * 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`.
+     */
+    compact(): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -178,7 +189,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * The `clone()` function returns a new Queue object with the same elements as the original Queue.
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
-    clone(): Queue<E>;
+    clone(): Queue<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -199,26 +210,12 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @returns The `filter` method is returning a new `Queue` object that contains the elements that
      * satisfy the given predicate function.
      */
-    filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Queue<E>;
+    filter(predicate: ElementCallback<E, R, boolean, Queue<E, R>>, thisArg?: any): Queue<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function takes a callback function and applies it to each element in the queue,
-     * returning a new queue with the results.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * queue. It takes three arguments: the current element, the index of the current element, and the
-     * queue itself. The callback function should return a new value that will be added to the new queue.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `map` function is returning a new `Queue` object with the transformed elements.
-     */
-    map<T>(callback: ElementCallback<E, T>, thisArg?: any): Queue<T>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM, Queue<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Queue<EM, RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -237,7 +234,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
  * 3. Memory Usage: Since each element requires additional space to store a pointer to the next element, linked lists may use more memory compared to arrays.
  * 4. Frequent Enqueuing and Dequeuing Operations: If your application involves frequent enqueuing and dequeuing operations and is less concerned with random access, then LinkedListQueue is a good choice.
  */
-export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
+export declare class LinkedListQueue<E = any, R = any> extends SinglyLinkedList<E, R> {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -250,5 +247,5 @@ export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
      * @returns The `clone()` method is returning a new instance of `LinkedListQueue` with the same
      * values as the original `LinkedListQueue`.
      */
-    clone(): LinkedListQueue<E>;
+    clone(): LinkedListQueue<E, R>;
 }

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

@@ -13,19 +13,22 @@ const linked_list_1 = require("../linked-list");
  * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
  */
 class Queue extends base_1.IterableElementBase {
-    /**
-     * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
-     * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
-     * will be used to initialize the `_elements` property of the class. If not provided, the `_elements` property will be
-     * initialized as an empty array.
-     */
-    constructor(elements = []) {
-        super();
+    constructor(elements = [], options) {
+        super(options);
         this._elements = [];
         this._offset = 0;
+        this._autoCompactRatio = 0.5;
+        if (options) {
+            const { autoCompactRatio = 0.5 } = options;
+            this._autoCompactRatio = autoCompactRatio;
+        }
         if (elements) {
-            for (const el of elements)
-                this.push(el);
+            for (const el of elements) {
+                if (this.toElementFn)
+                    this.push(this.toElementFn(el));
+                else
+                    this.push(el);
+            }
         }
     }
     /**
@@ -79,6 +82,21 @@ class Queue extends base_1.IterableElementBase {
     get last() {
         return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
     }
+    /**
+     * This function returns the value of the autoCompactRatio property.
+     * @returns The `autoCompactRatio` property of the object, which is a number.
+     */
+    get autoCompactRatio() {
+        return this._autoCompactRatio;
+    }
+    /**
+     * The above function sets the autoCompactRatio property to a specified number in TypeScript.
+     * @param {number} v - The parameter `v` represents the value that will be assigned to the
+     * `_autoCompactRatio` property.
+     */
+    set autoCompactRatio(v) {
+        this._autoCompactRatio = v;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -89,7 +107,6 @@ class Queue extends base_1.IterableElementBase {
      *
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
-     * @static
      * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
      * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
      * array.
@@ -130,12 +147,8 @@ class Queue extends base_1.IterableElementBase {
             return undefined;
         const first = this.first;
         this._offset += 1;
-        if (this.offset * 2 < this.elements.length)
-            return first;
-        // only delete dequeued elements when reaching half size
-        // to decrease latency of shifting elements.
-        this._elements = this.elements.slice(this.offset);
-        this._offset = 0;
+        if (this.offset / this.elements.length > this.autoCompactRatio)
+            this.compact();
         return first;
     }
     /**
@@ -167,7 +180,7 @@ class Queue extends base_1.IterableElementBase {
      * @param index
      */
     at(index) {
-        return this.elements[index];
+        return this.elements[index + this._offset];
     }
     /**
      * Time Complexity: O(1)
@@ -211,6 +224,16 @@ class Queue extends base_1.IterableElementBase {
         this._elements = [];
         this._offset = 0;
     }
+    /**
+     * 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`.
+     */
+    compact() {
+        this._elements = this.elements.slice(this.offset);
+        this._offset = 0;
+        return true;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -224,7 +247,7 @@ class Queue extends base_1.IterableElementBase {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone() {
-        return new Queue(this.elements.slice(this.offset));
+        return new Queue(this.elements.slice(this.offset), { toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -247,7 +270,7 @@ class Queue extends base_1.IterableElementBase {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-        const newDeque = new Queue([]);
+        const newDeque = new Queue([], { toElementFn: this.toElementFn });
         let index = 0;
         for (const el of this) {
             if (predicate.call(thisArg, el, index, this)) {
@@ -261,22 +284,8 @@ class Queue extends base_1.IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function takes a callback function and applies it to each element in the queue,
-     * returning a new queue with the results.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * queue. It takes three arguments: the current element, the index of the current element, and the
-     * queue itself. The callback function should return a new value that will be added to the new queue.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `map` function is returning a new `Queue` object with the transformed elements.
-     */
-    map(callback, thisArg) {
-        const newDeque = new Queue([]);
+    map(callback, toElementFn, thisArg) {
+        const newDeque = new Queue([], { toElementFn });
         let index = 0;
         for (const el of this) {
             newDeque.push(callback.call(thisArg, el, index, this));
@@ -295,7 +304,7 @@ class Queue extends base_1.IterableElementBase {
      * The function `_getIterator` returns an iterable iterator for the elements in the class.
      */
     *_getIterator() {
-        for (const item of this.elements) {
+        for (const item of this.elements.slice(this.offset)) {
             yield item;
         }
     }
@@ -321,7 +330,7 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
      * values as the original `LinkedListQueue`.
      */
     clone() {
-        return new LinkedListQueue(this.values());
+        return new LinkedListQueue(this, { toElementFn: this.toElementFn });
     }
 }
 exports.LinkedListQueue = LinkedListQueue;

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from '../../types';
+import type { ElementCallback, StackOptions } from '../../types';
 import { IterableElementBase } from '../base';
 /**
  * 1. Last In, First Out (LIFO): The core characteristic of a stack is its last in, first out nature, meaning the last element added to the stack will be the first to be removed.
@@ -15,14 +15,8 @@ import { IterableElementBase } from '../base';
  * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.
  * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.
  */
-export declare class Stack<E = any> extends IterableElementBase<E> {
-    /**
-     * The constructor initializes an array of elements, which can be provided as an optional parameter.
-     * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
-     * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
-     * is provided and is an array, it is assigned to the `_elements
-     */
-    constructor(elements?: Iterable<E>);
+export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, Stack<E, R>> {
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>);
     protected _elements: E[];
     /**
      * The elements function returns the elements of this set.
@@ -137,7 +131,7 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
-    clone(): Stack<E>;
+    clone(): Stack<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -158,25 +152,26 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * @returns The `filter` method is returning a new `Stack` object that contains the elements that
      * satisfy the given predicate function.
      */
-    filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Stack<E>;
+    filter(predicate: ElementCallback<E, R, boolean, Stack<E, R>>, thisArg?: any): Stack<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
      * The `map` function takes a callback function and applies it to each element in the stack,
      * returning a new stack with the results.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the stack. It takes three arguments:
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `map` method is returning a new `Stack` object.
-     */
-    map<T>(callback: ElementCallback<E, T>, thisArg?: any): Stack<T>;
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * stack. It takes three arguments: the current element, the index of the element, and the stack
+     * itself. It should return a new value that will be added to the new stack.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * transform the raw element (`RM`) into a new element (`EM`) before pushing it into the new stack.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new Stack object with elements of type EM and raw elements of type RM.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM, Stack<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Stack<EM, RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -11,18 +11,18 @@ const base_1 = require("../base");
  * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.
  */
 class Stack extends base_1.IterableElementBase {
-    /**
-     * The constructor initializes an array of elements, which can be provided as an optional parameter.
-     * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
-     * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
-     * is provided and is an array, it is assigned to the `_elements
-     */
-    constructor(elements = []) {
-        super();
+    constructor(elements = [], options) {
+        super(options);
         this._elements = [];
         if (elements) {
-            for (const el of elements)
-                this.push(el);
+            for (const el of elements) {
+                if (this.toElementFn) {
+                    this.push(this.toElementFn(el));
+                }
+                else {
+                    this.push(el);
+                }
+            }
         }
     }
     /**
@@ -168,7 +168,7 @@ class Stack extends base_1.IterableElementBase {
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
     clone() {
-        return new Stack(this.elements.slice());
+        return new Stack(this, { toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -191,7 +191,7 @@ class Stack extends base_1.IterableElementBase {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-        const newStack = new Stack();
+        const newStack = new Stack([], { toElementFn: this.toElementFn });
         let index = 0;
         for (const el of this) {
             if (predicate.call(thisArg, el, index, this)) {
@@ -206,20 +206,21 @@ class Stack extends base_1.IterableElementBase {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
      * The `map` function takes a callback function and applies it to each element in the stack,
      * returning a new stack with the results.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the stack. It takes three arguments:
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `map` method is returning a new `Stack` object.
-     */
-    map(callback, thisArg) {
-        const newStack = new Stack();
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * stack. It takes three arguments: the current element, the index of the element, and the stack
+     * itself. It should return a new value that will be added to the new stack.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * transform the raw element (`RM`) into a new element (`EM`) before pushing it into the new stack.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new Stack object with elements of type EM and raw elements of type RM.
+     */
+    map(callback, toElementFn, thisArg) {
+        const newStack = new Stack([], { toElementFn });
         let index = 0;
         for (const el of this) {
             newStack.push(callback.call(thisArg, el, index, this));

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

@@ -66,14 +66,14 @@ export declare class TrieNode {
  * 10. IP Routing: Used in certain types of IP routing algorithms.
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data.
  */
-export declare class Trie extends IterableElementBase<string, Trie> {
+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
      */
-    constructor(words?: Iterable<string>, options?: TrieOptions);
+    constructor(words?: Iterable<string> | Iterable<R>, options?: TrieOptions<R>);
     protected _size: number;
     /**
      * The size function returns the size of the stack.
@@ -243,7 +243,7 @@ export declare class Trie extends IterableElementBase<string, Trie> {
      * sensitivity as the original Trie.
      * @returns A new instance of the Trie class is being returned.
      */
-    clone(): Trie;
+    clone(): Trie<R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -262,7 +262,7 @@ export declare class Trie extends IterableElementBase<string, Trie> {
      * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
-    filter(predicate: ElementCallback<string, boolean>, thisArg?: any): Trie;
+    filter(predicate: ElementCallback<string, R, boolean, Trie<R>>, thisArg?: any): Trie<R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -271,16 +271,21 @@ export declare class Trie extends IterableElementBase<string, Trie> {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function creates a new Trie by applying a callback function to each element in the Trie.
+     * The `map` function creates a new Trie by applying a callback function to each element in the
+     * current Trie.
      * @param callback - The callback parameter is a function that will be called for each element in the
-     * Trie. It takes three arguments: the current element in the Trie, the index of the current element,
-     * and the Trie itself. The callback function should return a new value for the element.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `map` function is returning a new Trie object.
-     */
-    map(callback: ElementCallback<string, string>, thisArg?: any): Trie;
+     * Trie. It takes four arguments:
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * convert the raw element (`RM`) into a string representation. This can be useful if the raw element
+     * is not already a string or if you want to customize how the element is converted into a string. If
+     * this parameter is
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new Trie object.
+     */
+    map<RM>(callback: ElementCallback<string, R, string, Trie<R>>, toElementFn?: (rawElement: RM) => string, thisArg?: any): Trie<RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -83,7 +83,7 @@ class Trie extends base_1.IterableElementBase {
      * @return This
      */
     constructor(words = [], options) {
-        super();
+        super(options);
         this._size = 0;
         this._caseSensitive = true;
         this._root = new TrieNode('');
@@ -93,8 +93,14 @@ class Trie extends base_1.IterableElementBase {
                 this._caseSensitive = caseSensitive;
         }
         if (words) {
-            for (const word of words)
-                this.add(word);
+            for (const word of words) {
+                if (this.toElementFn) {
+                    this.add(this.toElementFn(word));
+                }
+                else {
+                    this.add(word);
+                }
+            }
         }
     }
     /**
@@ -433,7 +439,7 @@ class Trie extends base_1.IterableElementBase {
      * @returns A new instance of the Trie class is being returned.
      */
     clone() {
-        return new Trie(this.values(), { caseSensitive: this.caseSensitive });
+        return new Trie(this, { caseSensitive: this.caseSensitive, toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -454,7 +460,7 @@ class Trie extends base_1.IterableElementBase {
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
     filter(predicate, thisArg) {
-        const results = new Trie();
+        const results = new Trie([], { toElementFn: this.toElementFn, caseSensitive: this.caseSensitive });
         let index = 0;
         for (const word of this) {
             if (predicate.call(thisArg, word, index, this)) {
@@ -472,17 +478,22 @@ class Trie extends base_1.IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function creates a new Trie by applying a callback function to each element in the Trie.
+     * The `map` function creates a new Trie by applying a callback function to each element in the
+     * current Trie.
      * @param callback - The callback parameter is a function that will be called for each element in the
-     * Trie. It takes three arguments: the current element in the Trie, the index of the current element,
-     * and the Trie itself. The callback function should return a new value for the element.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `map` function is returning a new Trie object.
-     */
-    map(callback, thisArg) {
-        const newTrie = new Trie();
+     * Trie. It takes four arguments:
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * convert the raw element (`RM`) into a string representation. This can be useful if the raw element
+     * is not already a string or if you want to customize how the element is converted into a string. If
+     * this parameter is
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new Trie object.
+     */
+    map(callback, toElementFn, thisArg) {
+        const newTrie = new Trie([], { toElementFn, caseSensitive: this.caseSensitive });
         let index = 0;
         for (const word of this) {
             newTrie.add(callback.call(thisArg, word, index, this));

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

@@ -1,9 +1,9 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-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>> {
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKeyOrNodeOrEntry } from '../types';
+export interface IBinaryTree<K = any, 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[];
+    add(keyOrNodeOrEntryOrRawElement: BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
+    addMany(nodes: Iterable<BTNKeyOrNodeOrEntry<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,36 +1,15 @@
 export type CP = 1 | -1 | 0;
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
 export type IterationType = 'ITERATIVE' | 'RECURSIVE';
 export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
 export type Comparator<K> = (a: K, b: K) => number;
 export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 export type NodeDisplayLayout = [string[], number, number, number];
-export type BTNCallback<N, D = any> = (node: N) => D;
 export interface IterableWithSize<T> extends Iterable<T> {
     size: number | ((...args: any[]) => number);
 }
 export interface IterableWithLength<T> extends Iterable<T> {
     length: number | ((...args: any[]) => number);
 }
+export type OptValue<V> = V | undefined;
 export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
-export type BinaryTreePrintOptions = {
-    isShowUndefined?: boolean;
-    isShowNull?: boolean;
-    isShowRedBlackNIL?: boolean;
-};
-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 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;
-    needBalanced: N | null | undefined;
-};
 export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

package/dist/types/data-structures/base/base.d.ts

@@ -1,5 +1,8 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
 export type EntryCallback<K, V, R> = (value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
-export type ElementCallback<V, R> = (element: V, index: number, container: IterableElementBase<V>) => R;
+export type ElementCallback<E, R, RT, C> = (element: E, index: number, container: IterableElementBase<E, R, C>) => RT;
 export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
-export type ReduceElementCallback<V, R> = (accumulator: R, element: V, index: number, container: IterableElementBase<V>) => R;
+export type ReduceElementCallback<E, R, RT, C> = (accumulator: RT, element: E, index: number, container: IterableElementBase<E, R, C>) => RT;
+export type IterableElementBaseOptions<E, R> = {
+    toElementFn?: (rawElement: R) => E;
+};