bst-typed 2.0.0 → 2.0.3

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

@@ -250,7 +250,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
             isWeight = false;
         if (isWeight) {
             const allPaths = this.getAllPathsBetween(v1, v2);
-            let min = Infinity;
+            let min = Number.MAX_SAFE_INTEGER;
             for (const path of allPaths) {
                 min = Math.min(this.getPathSumWeight(path), min);
             }
@@ -315,7 +315,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         if (isWeight) {
             if (isDFS) {
                 const allPaths = this.getAllPathsBetween(v1, v2, 10000);
-                let min = Infinity;
+                let min = Number.MAX_SAFE_INTEGER;
                 let minIndex = -1;
                 let index = 0;
                 for (const path of allPaths) {
@@ -379,7 +379,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
     dijkstraWithoutHeap(src, dest = undefined, getMinDist = false, genPaths = false) {
-        let minDist = Infinity;
+        let minDist = Number.MAX_SAFE_INTEGER;
         let minDest = undefined;
         let minPath = [];
         const paths = [];
@@ -395,12 +395,12 @@ class AbstractGraph extends base_1.IterableEntryBase {
         for (const vertex of vertexMap) {
             const vertexOrKey = vertex[1];
             if (vertexOrKey instanceof AbstractVertex)
-                distMap.set(vertexOrKey, Infinity);
+                distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
         }
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, undefined);
         const getMinOfNoSeen = () => {
-            let min = Infinity;
+            let min = Number.MAX_SAFE_INTEGER;
             let minV = undefined;
             for (const [key, value] of distMap) {
                 if (!seen.has(key)) {
@@ -435,7 +435,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
                 seen.add(cur);
                 if (destVertex && destVertex === cur) {
                     if (getMinDist) {
-                        minDist = distMap.get(destVertex) || Infinity;
+                        minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
                     }
                     if (genPaths) {
                         getPaths(destVertex);
@@ -497,7 +497,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
      */
     dijkstra(src, dest = undefined, getMinDist = false, genPaths = false) {
         var _a;
-        let minDist = Infinity;
+        let minDist = Number.MAX_SAFE_INTEGER;
         let minDest = undefined;
         let minPath = [];
         const paths = [];
@@ -512,7 +512,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         for (const vertex of vertexMap) {
             const vertexOrKey = vertex[1];
             if (vertexOrKey instanceof AbstractVertex)
-                distMap.set(vertexOrKey, Infinity);
+                distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
         }
         const heap = new heap_1.Heap([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
@@ -549,7 +549,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
                     seen.add(cur);
                     if (destVertex && destVertex === cur) {
                         if (getMinDist) {
-                            minDist = distMap.get(destVertex) || Infinity;
+                            minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
                         }
                         if (genPaths) {
                             getPaths(destVertex);
@@ -618,7 +618,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         const paths = [];
         const distMap = new Map();
         const preMap = new Map(); // predecessor
-        let min = Infinity;
+        let min = Number.MAX_SAFE_INTEGER;
         let minPath = [];
         // TODO
         let hasNegativeCycle;
@@ -631,7 +631,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         const edgeMap = this.edgeSet();
         const numOfEdges = edgeMap.length;
         this._vertexMap.forEach(vertex => {
-            distMap.set(vertex, Infinity);
+            distMap.set(vertex, Number.MAX_SAFE_INTEGER);
         });
         distMap.set(srcVertex, 0);
         for (let i = 1; i < numOfVertices; ++i) {
@@ -643,7 +643,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
                     const sWeight = distMap.get(s);
                     const dWeight = distMap.get(d);
                     if (sWeight !== undefined && dWeight !== undefined) {
-                        if (distMap.get(s) !== Infinity && sWeight + weight < dWeight) {
+                        if (distMap.get(s) !== Number.MAX_SAFE_INTEGER && sWeight + weight < dWeight) {
                             distMap.set(d, sWeight + weight);
                             if (genPath)
                                 preMap.set(d, s);
@@ -688,7 +688,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
                 const weight = edgeMap[j].weight;
                 const sWeight = distMap.get(s);
                 if (sWeight) {
-                    if (sWeight !== Infinity && sWeight + weight < sWeight)
+                    if (sWeight !== Number.MAX_SAFE_INTEGER && sWeight + weight < sWeight)
                         hasNegativeCycle = true;
                 }
             }
@@ -738,7 +738,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         }
         for (let i = 0; i < n; i++) {
             for (let j = 0; j < n; j++) {
-                costs[i][j] = ((_a = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])) === null || _a === void 0 ? void 0 : _a.weight) || Infinity;
+                costs[i][j] = ((_a = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])) === null || _a === void 0 ? void 0 : _a.weight) || Number.MAX_SAFE_INTEGER;
             }
         }
         for (let k = 0; k < n; k++) {

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

@@ -13,6 +13,52 @@ import { IterableEntryBase } from '../base';
  * 3. Unique Keys: Keys are unique.
  * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
+ * @example
+ * // should maintain insertion order
+ *     const linkedHashMap = new LinkedHashMap<number, string>();
+ *     linkedHashMap.set(1, 'A');
+ *     linkedHashMap.set(2, 'B');
+ *     linkedHashMap.set(3, 'C');
+ *
+ *     const result = Array.from(linkedHashMap);
+ *     console.log(result); // [
+ *  //      [1, 'A'],
+ *  //      [2, 'B'],
+ *  //      [3, 'C']
+ *  //    ]
+ * @example
+ * // fast lookup of values by key
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(3, 'C');
+ *
+ *     console.log(hashMap.get(1)); // 'A'
+ *     console.log(hashMap.get(2)); // 'B'
+ *     console.log(hashMap.get(3)); // 'C'
+ *     console.log(hashMap.get(99)); // undefined
+ * @example
+ * // remove duplicates when adding multiple entries
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(1, 'C'); // Update value for key 1
+ *
+ *     console.log(hashMap.size); // 2
+ *     console.log(hashMap.get(1)); // 'C'
+ *     console.log(hashMap.get(2)); // 'B'
+ * @example
+ * // count occurrences of keys
+ *     const data = [1, 2, 1, 3, 2, 1];
+ *
+ *     const countMap = new HashMap<number, number>();
+ *     for (const key of data) {
+ *       countMap.set(key, (countMap.get(key) || 0) + 1);
+ *     }
+ *
+ *     console.log(countMap.get(1)); // 3
+ *     console.log(countMap.get(2)); // 2
+ *     console.log(countMap.get(3)); // 1
  */
 export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
     /**

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

@@ -9,6 +9,52 @@ const utils_1 = require("../../utils");
  * 3. Unique Keys: Keys are unique.
  * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
+ * @example
+ * // should maintain insertion order
+ *     const linkedHashMap = new LinkedHashMap<number, string>();
+ *     linkedHashMap.set(1, 'A');
+ *     linkedHashMap.set(2, 'B');
+ *     linkedHashMap.set(3, 'C');
+ *
+ *     const result = Array.from(linkedHashMap);
+ *     console.log(result); // [
+ *  //      [1, 'A'],
+ *  //      [2, 'B'],
+ *  //      [3, 'C']
+ *  //    ]
+ * @example
+ * // fast lookup of values by key
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(3, 'C');
+ *
+ *     console.log(hashMap.get(1)); // 'A'
+ *     console.log(hashMap.get(2)); // 'B'
+ *     console.log(hashMap.get(3)); // 'C'
+ *     console.log(hashMap.get(99)); // undefined
+ * @example
+ * // remove duplicates when adding multiple entries
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(1, 'C'); // Update value for key 1
+ *
+ *     console.log(hashMap.size); // 2
+ *     console.log(hashMap.get(1)); // 'C'
+ *     console.log(hashMap.get(2)); // 'B'
+ * @example
+ * // count occurrences of keys
+ *     const data = [1, 2, 1, 3, 2, 1];
+ *
+ *     const countMap = new HashMap<number, number>();
+ *     for (const key of data) {
+ *       countMap.set(key, (countMap.get(key) || 0) + 1);
+ *     }
+ *
+ *     console.log(countMap.get(1)); // 3
+ *     console.log(countMap.get(2)); // 2
+ *     console.log(countMap.get(3)); // 1
  */
 class HashMap extends base_1.IterableEntryBase {
     /**

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

@@ -25,6 +25,72 @@ export declare class SinglyLinkedListNode<E = any> extends LinkedListNode<E> {
  * 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.
  * Caution: Although our linked list classes provide methods such as at, setAt, addAt, and indexOf that are based on array indices, their time complexity, like that of the native Array.lastIndexOf, is 𝑂(𝑛). If you need to use these methods frequently, you might want to consider other data structures, such as Deque or Queue (designed for random access). Similarly, since the native Array.shift method has a time complexity of 𝑂(𝑛), using an array to simulate a queue can be inefficient. In such cases, you should use Queue or Deque, as these data structures leverage deferred array rearrangement, effectively reducing the average time complexity to 𝑂(1).
  *
+ * @example
+ * // implementation of a basic text editor
+ *     class TextEditor {
+ *       private content: SinglyLinkedList<string>;
+ *       private cursorIndex: number;
+ *       private undoStack: Stack<{ operation: string; data?: any }>;
+ *
+ *       constructor() {
+ *         this.content = new SinglyLinkedList<string>();
+ *         this.cursorIndex = 0; // Cursor starts at the beginning
+ *         this.undoStack = new Stack<{ operation: string; data?: any }>(); // Stack to keep track of operations for undo
+ *       }
+ *
+ *       insert(char: string) {
+ *         this.content.addAt(this.cursorIndex, char);
+ *         this.cursorIndex++;
+ *         this.undoStack.push({ operation: 'insert', data: { index: this.cursorIndex - 1 } });
+ *       }
+ *
+ *       delete() {
+ *         if (this.cursorIndex === 0) return; // Nothing to delete
+ *         const deleted = this.content.deleteAt(this.cursorIndex - 1);
+ *         this.cursorIndex--;
+ *         this.undoStack.push({ operation: 'delete', data: { index: this.cursorIndex, char: deleted } });
+ *       }
+ *
+ *       moveCursor(index: number) {
+ *         this.cursorIndex = Math.max(0, Math.min(index, this.content.length));
+ *       }
+ *
+ *       undo() {
+ *         if (this.undoStack.size === 0) return; // No operations to undo
+ *         const lastAction = this.undoStack.pop();
+ *
+ *         if (lastAction!.operation === 'insert') {
+ *           this.content.deleteAt(lastAction!.data.index);
+ *           this.cursorIndex = lastAction!.data.index;
+ *         } else if (lastAction!.operation === 'delete') {
+ *           this.content.addAt(lastAction!.data.index, lastAction!.data.char);
+ *           this.cursorIndex = lastAction!.data.index + 1;
+ *         }
+ *       }
+ *
+ *       getText(): string {
+ *         return [...this.content].join('');
+ *       }
+ *     }
+ *
+ *     // Example Usage
+ *     const editor = new TextEditor();
+ *     editor.insert('H');
+ *     editor.insert('e');
+ *     editor.insert('l');
+ *     editor.insert('l');
+ *     editor.insert('o');
+ *     console.log(editor.getText()); // 'Hello' // Output: "Hello"
+ *
+ *     editor.delete();
+ *     console.log(editor.getText()); // 'Hell' // Output: "Hell"
+ *
+ *     editor.undo();
+ *     console.log(editor.getText()); // 'Hello' // Output: "Hello"
+ *
+ *     editor.moveCursor(1);
+ *     editor.insert('a');
+ *     console.log(editor.getText()); // 'Haello'
  */
 export declare class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, SinglyLinkedListNode<E>> {
     constructor(elements?: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>, options?: SinglyLinkedListOptions<E, R>);

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

@@ -28,6 +28,72 @@ exports.SinglyLinkedListNode = SinglyLinkedListNode;
  * 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.
  * Caution: Although our linked list classes provide methods such as at, setAt, addAt, and indexOf that are based on array indices, their time complexity, like that of the native Array.lastIndexOf, is 𝑂(𝑛). If you need to use these methods frequently, you might want to consider other data structures, such as Deque or Queue (designed for random access). Similarly, since the native Array.shift method has a time complexity of 𝑂(𝑛), using an array to simulate a queue can be inefficient. In such cases, you should use Queue or Deque, as these data structures leverage deferred array rearrangement, effectively reducing the average time complexity to 𝑂(1).
  *
+ * @example
+ * // implementation of a basic text editor
+ *     class TextEditor {
+ *       private content: SinglyLinkedList<string>;
+ *       private cursorIndex: number;
+ *       private undoStack: Stack<{ operation: string; data?: any }>;
+ *
+ *       constructor() {
+ *         this.content = new SinglyLinkedList<string>();
+ *         this.cursorIndex = 0; // Cursor starts at the beginning
+ *         this.undoStack = new Stack<{ operation: string; data?: any }>(); // Stack to keep track of operations for undo
+ *       }
+ *
+ *       insert(char: string) {
+ *         this.content.addAt(this.cursorIndex, char);
+ *         this.cursorIndex++;
+ *         this.undoStack.push({ operation: 'insert', data: { index: this.cursorIndex - 1 } });
+ *       }
+ *
+ *       delete() {
+ *         if (this.cursorIndex === 0) return; // Nothing to delete
+ *         const deleted = this.content.deleteAt(this.cursorIndex - 1);
+ *         this.cursorIndex--;
+ *         this.undoStack.push({ operation: 'delete', data: { index: this.cursorIndex, char: deleted } });
+ *       }
+ *
+ *       moveCursor(index: number) {
+ *         this.cursorIndex = Math.max(0, Math.min(index, this.content.length));
+ *       }
+ *
+ *       undo() {
+ *         if (this.undoStack.size === 0) return; // No operations to undo
+ *         const lastAction = this.undoStack.pop();
+ *
+ *         if (lastAction!.operation === 'insert') {
+ *           this.content.deleteAt(lastAction!.data.index);
+ *           this.cursorIndex = lastAction!.data.index;
+ *         } else if (lastAction!.operation === 'delete') {
+ *           this.content.addAt(lastAction!.data.index, lastAction!.data.char);
+ *           this.cursorIndex = lastAction!.data.index + 1;
+ *         }
+ *       }
+ *
+ *       getText(): string {
+ *         return [...this.content].join('');
+ *       }
+ *     }
+ *
+ *     // Example Usage
+ *     const editor = new TextEditor();
+ *     editor.insert('H');
+ *     editor.insert('e');
+ *     editor.insert('l');
+ *     editor.insert('l');
+ *     editor.insert('o');
+ *     console.log(editor.getText()); // 'Hello' // Output: "Hello"
+ *
+ *     editor.delete();
+ *     console.log(editor.getText()); // 'Hell' // Output: "Hell"
+ *
+ *     editor.undo();
+ *     console.log(editor.getText()); // 'Hello' // Output: "Hello"
+ *
+ *     editor.moveCursor(1);
+ *     editor.insert('a');
+ *     console.log(editor.getText()); // 'Haello'
  */
 class SinglyLinkedList extends linear_base_1.LinearLinkedBase {
     constructor(elements = [], options) {

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

@@ -14,6 +14,53 @@ import { LinearBase } from '../base/linear-base';
  * 5. Data Buffering: Acting as a buffer for data packets in network communication.
  * 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.
+ * @example
+ * // Sliding Window using Queue
+ *     const nums = [2, 3, 4, 1, 5];
+ *     const k = 2;
+ *     const queue = new Queue<number>();
+ *
+ *     let maxSum = 0;
+ *     let currentSum = 0;
+ *
+ *     nums.forEach((num) => {
+ *       queue.push(num);
+ *       currentSum += num;
+ *
+ *       if (queue.length > k) {
+ *         currentSum -= queue.shift()!;
+ *       }
+ *
+ *       if (queue.length === k) {
+ *         maxSum = Math.max(maxSum, currentSum);
+ *       }
+ *     });
+ *
+ *     console.log(maxSum); // 7
+ * @example
+ * // Breadth-First Search (BFS) using Queue
+ *     const graph: { [key in number]: number[] } = {
+ *       1: [2, 3],
+ *       2: [4, 5],
+ *       3: [],
+ *       4: [],
+ *       5: []
+ *     };
+ *
+ *     const queue = new Queue<number>();
+ *     const visited: number[] = [];
+ *
+ *     queue.push(1);
+ *
+ *     while (!queue.isEmpty()) {
+ *       const node = queue.shift()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => queue.push(neighbor));
+ *       }
+ *     }
+ *
+ *     console.log(visited); // [1, 2, 3, 4, 5]
  */
 export declare class Queue<E = any, R = any> extends LinearBase<E, R> {
     constructor(elements?: Iterable<E> | Iterable<R>, options?: QueueOptions<E, R>);

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

@@ -11,6 +11,53 @@ const linear_base_1 = require("../base/linear-base");
  * 5. Data Buffering: Acting as a buffer for data packets in network communication.
  * 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.
+ * @example
+ * // Sliding Window using Queue
+ *     const nums = [2, 3, 4, 1, 5];
+ *     const k = 2;
+ *     const queue = new Queue<number>();
+ *
+ *     let maxSum = 0;
+ *     let currentSum = 0;
+ *
+ *     nums.forEach((num) => {
+ *       queue.push(num);
+ *       currentSum += num;
+ *
+ *       if (queue.length > k) {
+ *         currentSum -= queue.shift()!;
+ *       }
+ *
+ *       if (queue.length === k) {
+ *         maxSum = Math.max(maxSum, currentSum);
+ *       }
+ *     });
+ *
+ *     console.log(maxSum); // 7
+ * @example
+ * // Breadth-First Search (BFS) using Queue
+ *     const graph: { [key in number]: number[] } = {
+ *       1: [2, 3],
+ *       2: [4, 5],
+ *       3: [],
+ *       4: [],
+ *       5: []
+ *     };
+ *
+ *     const queue = new Queue<number>();
+ *     const visited: number[] = [];
+ *
+ *     queue.push(1);
+ *
+ *     while (!queue.isEmpty()) {
+ *       const node = queue.shift()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => queue.push(neighbor));
+ *       }
+ *     }
+ *
+ *     console.log(visited); // [1, 2, 3, 4, 5]
  */
 class Queue extends linear_base_1.LinearBase {
     constructor(elements = [], options) {

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

@@ -14,6 +14,127 @@ import { IterableElementBase } from '../base';
  * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.
  * 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.
+ * @example
+ * // Balanced Parentheses or Brackets
+ *     type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';
+ *
+ *     const stack = new Stack<string>();
+ *     const input: ValidCharacters[] = '[({})]'.split('') as ValidCharacters[];
+ *     const matches: { [key in ValidCharacters]?: ValidCharacters } = { ')': '(', ']': '[', '}': '{' };
+ *     for (const char of input) {
+ *       if ('([{'.includes(char)) {
+ *         stack.push(char);
+ *       } else if (')]}'.includes(char)) {
+ *         if (stack.pop() !== matches[char]) {
+ *           fail('Parentheses are not balanced');
+ *         }
+ *       }
+ *     }
+ *     console.log(stack.isEmpty()); // true
+ * @example
+ * // Expression Evaluation and Conversion
+ *     const stack = new Stack<number>();
+ *     const expression = [5, 3, '+']; // Equivalent to 5 + 3
+ *     expression.forEach(token => {
+ *       if (typeof token === 'number') {
+ *         stack.push(token);
+ *       } else {
+ *         const b = stack.pop()!;
+ *         const a = stack.pop()!;
+ *         stack.push(token === '+' ? a + b : 0); // Only handling '+' here
+ *       }
+ *     });
+ *     console.log(stack.pop()); // 8
+ * @example
+ * // Depth-First Search (DFS)
+ *     const stack = new Stack<number>();
+ *     const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };
+ *     const visited: number[] = [];
+ *     stack.push(1);
+ *     while (!stack.isEmpty()) {
+ *       const node = stack.pop()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => stack.push(neighbor));
+ *       }
+ *     }
+ *     console.log(visited); // [1, 3, 5, 2, 4]
+ * @example
+ * // Backtracking Algorithms
+ *     const stack = new Stack<[number, number]>();
+ *     const maze = [
+ *       ['S', ' ', 'X'],
+ *       ['X', ' ', 'X'],
+ *       [' ', ' ', 'E']
+ *     ];
+ *     const start: [number, number] = [0, 0];
+ *     const end = [2, 2];
+ *     const directions = [
+ *       [0, 1], // To the right
+ *       [1, 0], // down
+ *       [0, -1], // left
+ *       [-1, 0] // up
+ *     ];
+ *
+ *     const visited = new Set<string>(); // Used to record visited nodes
+ *     stack.push(start);
+ *     const path: number[][] = [];
+ *
+ *     while (!stack.isEmpty()) {
+ *       const [x, y] = stack.pop()!;
+ *       if (visited.has(`${x},${y}`)) continue; // Skip already visited nodes
+ *       visited.add(`${x},${y}`);
+ *
+ *       path.push([x, y]);
+ *
+ *       if (x === end[0] && y === end[1]) {
+ *         break; // Find the end point and exit
+ *       }
+ *
+ *       for (const [dx, dy] of directions) {
+ *         const nx = x + dx;
+ *         const ny = y + dy;
+ *         if (
+ *           maze[nx]?.[ny] === ' ' || // feasible path
+ *           maze[nx]?.[ny] === 'E' // destination
+ *         ) {
+ *           stack.push([nx, ny]);
+ *         }
+ *       }
+ *     }
+ *
+ *     expect(path).toContainEqual(end);
+ * @example
+ * // Function Call Stack
+ *     const functionStack = new Stack<string>();
+ *     functionStack.push('main');
+ *     functionStack.push('foo');
+ *     functionStack.push('bar');
+ *     console.log(functionStack.pop()); // 'bar'
+ *     console.log(functionStack.pop()); // 'foo'
+ *     console.log(functionStack.pop()); // 'main'
+ * @example
+ * // Simplify File Paths
+ *     const stack = new Stack<string>();
+ *     const path = '/a/./b/../../c';
+ *     path.split('/').forEach(segment => {
+ *       if (segment === '..') stack.pop();
+ *       else if (segment && segment !== '.') stack.push(segment);
+ *     });
+ *     console.log(stack.elements.join('/')); // 'c'
+ * @example
+ * // Stock Span Problem
+ *     const stack = new Stack<number>();
+ *     const prices = [100, 80, 60, 70, 60, 75, 85];
+ *     const spans: number[] = [];
+ *     prices.forEach((price, i) => {
+ *       while (!stack.isEmpty() && prices[stack.peek()!] <= price) {
+ *         stack.pop();
+ *       }
+ *       spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);
+ *       stack.push(i);
+ *     });
+ *     console.log(spans); // [1, 1, 1, 2, 1, 4, 6]
  */
 export declare class Stack<E = any, R = any> extends IterableElementBase<E, R> {
     constructor(elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>);

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

@@ -9,6 +9,127 @@ const base_1 = require("../base");
  * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.
  * 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.
+ * @example
+ * // Balanced Parentheses or Brackets
+ *     type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';
+ *
+ *     const stack = new Stack<string>();
+ *     const input: ValidCharacters[] = '[({})]'.split('') as ValidCharacters[];
+ *     const matches: { [key in ValidCharacters]?: ValidCharacters } = { ')': '(', ']': '[', '}': '{' };
+ *     for (const char of input) {
+ *       if ('([{'.includes(char)) {
+ *         stack.push(char);
+ *       } else if (')]}'.includes(char)) {
+ *         if (stack.pop() !== matches[char]) {
+ *           fail('Parentheses are not balanced');
+ *         }
+ *       }
+ *     }
+ *     console.log(stack.isEmpty()); // true
+ * @example
+ * // Expression Evaluation and Conversion
+ *     const stack = new Stack<number>();
+ *     const expression = [5, 3, '+']; // Equivalent to 5 + 3
+ *     expression.forEach(token => {
+ *       if (typeof token === 'number') {
+ *         stack.push(token);
+ *       } else {
+ *         const b = stack.pop()!;
+ *         const a = stack.pop()!;
+ *         stack.push(token === '+' ? a + b : 0); // Only handling '+' here
+ *       }
+ *     });
+ *     console.log(stack.pop()); // 8
+ * @example
+ * // Depth-First Search (DFS)
+ *     const stack = new Stack<number>();
+ *     const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };
+ *     const visited: number[] = [];
+ *     stack.push(1);
+ *     while (!stack.isEmpty()) {
+ *       const node = stack.pop()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => stack.push(neighbor));
+ *       }
+ *     }
+ *     console.log(visited); // [1, 3, 5, 2, 4]
+ * @example
+ * // Backtracking Algorithms
+ *     const stack = new Stack<[number, number]>();
+ *     const maze = [
+ *       ['S', ' ', 'X'],
+ *       ['X', ' ', 'X'],
+ *       [' ', ' ', 'E']
+ *     ];
+ *     const start: [number, number] = [0, 0];
+ *     const end = [2, 2];
+ *     const directions = [
+ *       [0, 1], // To the right
+ *       [1, 0], // down
+ *       [0, -1], // left
+ *       [-1, 0] // up
+ *     ];
+ *
+ *     const visited = new Set<string>(); // Used to record visited nodes
+ *     stack.push(start);
+ *     const path: number[][] = [];
+ *
+ *     while (!stack.isEmpty()) {
+ *       const [x, y] = stack.pop()!;
+ *       if (visited.has(`${x},${y}`)) continue; // Skip already visited nodes
+ *       visited.add(`${x},${y}`);
+ *
+ *       path.push([x, y]);
+ *
+ *       if (x === end[0] && y === end[1]) {
+ *         break; // Find the end point and exit
+ *       }
+ *
+ *       for (const [dx, dy] of directions) {
+ *         const nx = x + dx;
+ *         const ny = y + dy;
+ *         if (
+ *           maze[nx]?.[ny] === ' ' || // feasible path
+ *           maze[nx]?.[ny] === 'E' // destination
+ *         ) {
+ *           stack.push([nx, ny]);
+ *         }
+ *       }
+ *     }
+ *
+ *     expect(path).toContainEqual(end);
+ * @example
+ * // Function Call Stack
+ *     const functionStack = new Stack<string>();
+ *     functionStack.push('main');
+ *     functionStack.push('foo');
+ *     functionStack.push('bar');
+ *     console.log(functionStack.pop()); // 'bar'
+ *     console.log(functionStack.pop()); // 'foo'
+ *     console.log(functionStack.pop()); // 'main'
+ * @example
+ * // Simplify File Paths
+ *     const stack = new Stack<string>();
+ *     const path = '/a/./b/../../c';
+ *     path.split('/').forEach(segment => {
+ *       if (segment === '..') stack.pop();
+ *       else if (segment && segment !== '.') stack.push(segment);
+ *     });
+ *     console.log(stack.elements.join('/')); // 'c'
+ * @example
+ * // Stock Span Problem
+ *     const stack = new Stack<number>();
+ *     const prices = [100, 80, 60, 70, 60, 75, 85];
+ *     const spans: number[] = [];
+ *     prices.forEach((price, i) => {
+ *       while (!stack.isEmpty() && prices[stack.peek()!] <= price) {
+ *         stack.pop();
+ *       }
+ *       spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);
+ *       stack.push(i);
+ *     });
+ *     console.log(spans); // [1, 1, 1, 2, 1, 4, 6]
  */
 class Stack extends base_1.IterableElementBase {
     constructor(elements = [], options) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bst-typed",
-  "version": "2.0.0",
-  "description": "BST (Binary Search Tree). Javascript & Typescript Data Structure.",
+  "version": "2.0.3",
+  "description": "Binary Search Tree",
   "main": "dist/index.js",
   "scripts": {
     "build": "rm -rf dist && npx tsc",
@@ -144,6 +144,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^2.0.0"
+    "data-structure-typed": "^2.0.3"
   }
 }

package/src/data-structures/graph/abstract-graph.ts

@@ -339,7 +339,7 @@ export abstract class AbstractGraph<
 
     if (isWeight) {
       const allPaths = this.getAllPathsBetween(v1, v2);
-      let min = Infinity;
+      let min = Number.MAX_SAFE_INTEGER;
       for (const path of allPaths) {
         min = Math.min(this.getPathSumWeight(path), min);
       }
@@ -404,7 +404,7 @@ export abstract class AbstractGraph<
     if (isWeight) {
       if (isDFS) {
         const allPaths = this.getAllPathsBetween(v1, v2, 10000);
-        let min = Infinity;
+        let min = Number.MAX_SAFE_INTEGER;
         let minIndex = -1;
         let index = 0;
         for (const path of allPaths) {
@@ -475,7 +475,7 @@ export abstract class AbstractGraph<
     getMinDist: boolean = false,
     genPaths: boolean = false
   ): DijkstraResult<VO> {
-    let minDist = Infinity;
+    let minDist = Number.MAX_SAFE_INTEGER;
     let minDest: VO | undefined = undefined;
     let minPath: VO[] = [];
     const paths: VO[][] = [];
@@ -494,13 +494,13 @@ export abstract class AbstractGraph<
 
     for (const vertex of vertexMap) {
       const vertexOrKey = vertex[1];
-      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
+      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
     }
     distMap.set(srcVertex, 0);
     preMap.set(srcVertex, undefined);
 
     const getMinOfNoSeen = () => {
-      let min = Infinity;
+      let min = Number.MAX_SAFE_INTEGER;
       let minV: VO | undefined = undefined;
       for (const [key, value] of distMap) {
         if (!seen.has(key)) {
@@ -537,7 +537,7 @@ export abstract class AbstractGraph<
         seen.add(cur);
         if (destVertex && destVertex === cur) {
           if (getMinDist) {
-            minDist = distMap.get(destVertex) || Infinity;
+            minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
           }
           if (genPaths) {
             getPaths(destVertex);
@@ -605,7 +605,7 @@ export abstract class AbstractGraph<
     getMinDist: boolean = false,
     genPaths: boolean = false
   ): DijkstraResult<VO> {
-    let minDist = Infinity;
+    let minDist = Number.MAX_SAFE_INTEGER;
     let minDest: VO | undefined = undefined;
     let minPath: VO[] = [];
     const paths: VO[][] = [];
@@ -621,7 +621,7 @@ export abstract class AbstractGraph<
 
     for (const vertex of vertexMap) {
       const vertexOrKey = vertex[1];
-      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
+      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
     }
 
     const heap = new Heap<{ key: number; value: VO }>([], { comparator: (a, b) => a.key - b.key });
@@ -661,7 +661,7 @@ export abstract class AbstractGraph<
           seen.add(cur);
           if (destVertex && destVertex === cur) {
             if (getMinDist) {
-              minDist = distMap.get(destVertex) || Infinity;
+              minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
             }
             if (genPaths) {
               getPaths(destVertex);
@@ -732,7 +732,7 @@ export abstract class AbstractGraph<
     const paths: VO[][] = [];
     const distMap: Map<VO, number> = new Map();
     const preMap: Map<VO, VO> = new Map(); // predecessor
-    let min = Infinity;
+    let min = Number.MAX_SAFE_INTEGER;
     let minPath: VO[] = [];
     // TODO
     let hasNegativeCycle: boolean | undefined;
@@ -745,7 +745,7 @@ export abstract class AbstractGraph<
     const numOfEdges = edgeMap.length;
 
     this._vertexMap.forEach(vertex => {
-      distMap.set(vertex, Infinity);
+      distMap.set(vertex, Number.MAX_SAFE_INTEGER);
     });
 
     distMap.set(srcVertex, 0);
@@ -759,7 +759,7 @@ export abstract class AbstractGraph<
           const sWeight = distMap.get(s);
           const dWeight = distMap.get(d);
           if (sWeight !== undefined && dWeight !== undefined) {
-            if (distMap.get(s) !== Infinity && sWeight + weight < dWeight) {
+            if (distMap.get(s) !== Number.MAX_SAFE_INTEGER && sWeight + weight < dWeight) {
               distMap.set(d, sWeight + weight);
               if (genPath) preMap.set(d, s);
             }
@@ -804,7 +804,7 @@ export abstract class AbstractGraph<
         const weight = edgeMap[j].weight;
         const sWeight = distMap.get(s);
         if (sWeight) {
-          if (sWeight !== Infinity && sWeight + weight < sWeight) hasNegativeCycle = true;
+          if (sWeight !== Number.MAX_SAFE_INTEGER && sWeight + weight < sWeight) hasNegativeCycle = true;
         }
       }
     }
@@ -860,7 +860,7 @@ export abstract class AbstractGraph<
 
     for (let i = 0; i < n; i++) {
       for (let j = 0; j < n; j++) {
-        costs[i][j] = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])?.weight || Infinity;
+        costs[i][j] = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])?.weight || Number.MAX_SAFE_INTEGER;
       }
     }
 

package/src/data-structures/hash/hash-map.ts

@@ -21,6 +21,52 @@ import { isWeakKey, rangeCheck } from '../../utils';
  * 3. Unique Keys: Keys are unique.
  * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
+ * @example
+ * // should maintain insertion order
+ *     const linkedHashMap = new LinkedHashMap<number, string>();
+ *     linkedHashMap.set(1, 'A');
+ *     linkedHashMap.set(2, 'B');
+ *     linkedHashMap.set(3, 'C');
+ *
+ *     const result = Array.from(linkedHashMap);
+ *     console.log(result); // [
+ *  //      [1, 'A'],
+ *  //      [2, 'B'],
+ *  //      [3, 'C']
+ *  //    ]
+ * @example
+ * // fast lookup of values by key
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(3, 'C');
+ *
+ *     console.log(hashMap.get(1)); // 'A'
+ *     console.log(hashMap.get(2)); // 'B'
+ *     console.log(hashMap.get(3)); // 'C'
+ *     console.log(hashMap.get(99)); // undefined
+ * @example
+ * // remove duplicates when adding multiple entries
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(1, 'C'); // Update value for key 1
+ *
+ *     console.log(hashMap.size); // 2
+ *     console.log(hashMap.get(1)); // 'C'
+ *     console.log(hashMap.get(2)); // 'B'
+ * @example
+ * // count occurrences of keys
+ *     const data = [1, 2, 1, 3, 2, 1];
+ *
+ *     const countMap = new HashMap<number, number>();
+ *     for (const key of data) {
+ *       countMap.set(key, (countMap.get(key) || 0) + 1);
+ *     }
+ *
+ *     console.log(countMap.get(1)); // 3
+ *     console.log(countMap.get(2)); // 2
+ *     console.log(countMap.get(3)); // 1
  */
 export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
   /**

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -38,6 +38,72 @@ export class SinglyLinkedListNode<E = any> extends LinkedListNode<E> {
  * 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.
  * Caution: Although our linked list classes provide methods such as at, setAt, addAt, and indexOf that are based on array indices, their time complexity, like that of the native Array.lastIndexOf, is 𝑂(𝑛). If you need to use these methods frequently, you might want to consider other data structures, such as Deque or Queue (designed for random access). Similarly, since the native Array.shift method has a time complexity of 𝑂(𝑛), using an array to simulate a queue can be inefficient. In such cases, you should use Queue or Deque, as these data structures leverage deferred array rearrangement, effectively reducing the average time complexity to 𝑂(1).
  *
+ * @example
+ * // implementation of a basic text editor
+ *     class TextEditor {
+ *       private content: SinglyLinkedList<string>;
+ *       private cursorIndex: number;
+ *       private undoStack: Stack<{ operation: string; data?: any }>;
+ *
+ *       constructor() {
+ *         this.content = new SinglyLinkedList<string>();
+ *         this.cursorIndex = 0; // Cursor starts at the beginning
+ *         this.undoStack = new Stack<{ operation: string; data?: any }>(); // Stack to keep track of operations for undo
+ *       }
+ *
+ *       insert(char: string) {
+ *         this.content.addAt(this.cursorIndex, char);
+ *         this.cursorIndex++;
+ *         this.undoStack.push({ operation: 'insert', data: { index: this.cursorIndex - 1 } });
+ *       }
+ *
+ *       delete() {
+ *         if (this.cursorIndex === 0) return; // Nothing to delete
+ *         const deleted = this.content.deleteAt(this.cursorIndex - 1);
+ *         this.cursorIndex--;
+ *         this.undoStack.push({ operation: 'delete', data: { index: this.cursorIndex, char: deleted } });
+ *       }
+ *
+ *       moveCursor(index: number) {
+ *         this.cursorIndex = Math.max(0, Math.min(index, this.content.length));
+ *       }
+ *
+ *       undo() {
+ *         if (this.undoStack.size === 0) return; // No operations to undo
+ *         const lastAction = this.undoStack.pop();
+ *
+ *         if (lastAction!.operation === 'insert') {
+ *           this.content.deleteAt(lastAction!.data.index);
+ *           this.cursorIndex = lastAction!.data.index;
+ *         } else if (lastAction!.operation === 'delete') {
+ *           this.content.addAt(lastAction!.data.index, lastAction!.data.char);
+ *           this.cursorIndex = lastAction!.data.index + 1;
+ *         }
+ *       }
+ *
+ *       getText(): string {
+ *         return [...this.content].join('');
+ *       }
+ *     }
+ *
+ *     // Example Usage
+ *     const editor = new TextEditor();
+ *     editor.insert('H');
+ *     editor.insert('e');
+ *     editor.insert('l');
+ *     editor.insert('l');
+ *     editor.insert('o');
+ *     console.log(editor.getText()); // 'Hello' // Output: "Hello"
+ *
+ *     editor.delete();
+ *     console.log(editor.getText()); // 'Hell' // Output: "Hell"
+ *
+ *     editor.undo();
+ *     console.log(editor.getText()); // 'Hello' // Output: "Hello"
+ *
+ *     editor.moveCursor(1);
+ *     editor.insert('a');
+ *     console.log(editor.getText()); // 'Haello'
  */
 export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, SinglyLinkedListNode<E>> {
   constructor(

package/src/data-structures/queue/queue.ts

@@ -15,6 +15,53 @@ import { LinearBase } from '../base/linear-base';
  * 5. Data Buffering: Acting as a buffer for data packets in network communication.
  * 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.
+ * @example
+ * // Sliding Window using Queue
+ *     const nums = [2, 3, 4, 1, 5];
+ *     const k = 2;
+ *     const queue = new Queue<number>();
+ *
+ *     let maxSum = 0;
+ *     let currentSum = 0;
+ *
+ *     nums.forEach((num) => {
+ *       queue.push(num);
+ *       currentSum += num;
+ *
+ *       if (queue.length > k) {
+ *         currentSum -= queue.shift()!;
+ *       }
+ *
+ *       if (queue.length === k) {
+ *         maxSum = Math.max(maxSum, currentSum);
+ *       }
+ *     });
+ *
+ *     console.log(maxSum); // 7
+ * @example
+ * // Breadth-First Search (BFS) using Queue
+ *     const graph: { [key in number]: number[] } = {
+ *       1: [2, 3],
+ *       2: [4, 5],
+ *       3: [],
+ *       4: [],
+ *       5: []
+ *     };
+ *
+ *     const queue = new Queue<number>();
+ *     const visited: number[] = [];
+ *
+ *     queue.push(1);
+ *
+ *     while (!queue.isEmpty()) {
+ *       const node = queue.shift()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => queue.push(neighbor));
+ *       }
+ *     }
+ *
+ *     console.log(visited); // [1, 2, 3, 4, 5]
  */
 export class Queue<E = any, R = any> extends LinearBase<E, R> {
   constructor(elements: Iterable<E> | Iterable<R> = [], options?: QueueOptions<E, R>) {

package/src/data-structures/stack/stack.ts

@@ -15,6 +15,127 @@ import { IterableElementBase } from '../base';
  * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.
  * 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.
+ * @example
+ * // Balanced Parentheses or Brackets
+ *     type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';
+ *
+ *     const stack = new Stack<string>();
+ *     const input: ValidCharacters[] = '[({})]'.split('') as ValidCharacters[];
+ *     const matches: { [key in ValidCharacters]?: ValidCharacters } = { ')': '(', ']': '[', '}': '{' };
+ *     for (const char of input) {
+ *       if ('([{'.includes(char)) {
+ *         stack.push(char);
+ *       } else if (')]}'.includes(char)) {
+ *         if (stack.pop() !== matches[char]) {
+ *           fail('Parentheses are not balanced');
+ *         }
+ *       }
+ *     }
+ *     console.log(stack.isEmpty()); // true
+ * @example
+ * // Expression Evaluation and Conversion
+ *     const stack = new Stack<number>();
+ *     const expression = [5, 3, '+']; // Equivalent to 5 + 3
+ *     expression.forEach(token => {
+ *       if (typeof token === 'number') {
+ *         stack.push(token);
+ *       } else {
+ *         const b = stack.pop()!;
+ *         const a = stack.pop()!;
+ *         stack.push(token === '+' ? a + b : 0); // Only handling '+' here
+ *       }
+ *     });
+ *     console.log(stack.pop()); // 8
+ * @example
+ * // Depth-First Search (DFS)
+ *     const stack = new Stack<number>();
+ *     const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };
+ *     const visited: number[] = [];
+ *     stack.push(1);
+ *     while (!stack.isEmpty()) {
+ *       const node = stack.pop()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => stack.push(neighbor));
+ *       }
+ *     }
+ *     console.log(visited); // [1, 3, 5, 2, 4]
+ * @example
+ * // Backtracking Algorithms
+ *     const stack = new Stack<[number, number]>();
+ *     const maze = [
+ *       ['S', ' ', 'X'],
+ *       ['X', ' ', 'X'],
+ *       [' ', ' ', 'E']
+ *     ];
+ *     const start: [number, number] = [0, 0];
+ *     const end = [2, 2];
+ *     const directions = [
+ *       [0, 1], // To the right
+ *       [1, 0], // down
+ *       [0, -1], // left
+ *       [-1, 0] // up
+ *     ];
+ *
+ *     const visited = new Set<string>(); // Used to record visited nodes
+ *     stack.push(start);
+ *     const path: number[][] = [];
+ *
+ *     while (!stack.isEmpty()) {
+ *       const [x, y] = stack.pop()!;
+ *       if (visited.has(`${x},${y}`)) continue; // Skip already visited nodes
+ *       visited.add(`${x},${y}`);
+ *
+ *       path.push([x, y]);
+ *
+ *       if (x === end[0] && y === end[1]) {
+ *         break; // Find the end point and exit
+ *       }
+ *
+ *       for (const [dx, dy] of directions) {
+ *         const nx = x + dx;
+ *         const ny = y + dy;
+ *         if (
+ *           maze[nx]?.[ny] === ' ' || // feasible path
+ *           maze[nx]?.[ny] === 'E' // destination
+ *         ) {
+ *           stack.push([nx, ny]);
+ *         }
+ *       }
+ *     }
+ *
+ *     expect(path).toContainEqual(end);
+ * @example
+ * // Function Call Stack
+ *     const functionStack = new Stack<string>();
+ *     functionStack.push('main');
+ *     functionStack.push('foo');
+ *     functionStack.push('bar');
+ *     console.log(functionStack.pop()); // 'bar'
+ *     console.log(functionStack.pop()); // 'foo'
+ *     console.log(functionStack.pop()); // 'main'
+ * @example
+ * // Simplify File Paths
+ *     const stack = new Stack<string>();
+ *     const path = '/a/./b/../../c';
+ *     path.split('/').forEach(segment => {
+ *       if (segment === '..') stack.pop();
+ *       else if (segment && segment !== '.') stack.push(segment);
+ *     });
+ *     console.log(stack.elements.join('/')); // 'c'
+ * @example
+ * // Stock Span Problem
+ *     const stack = new Stack<number>();
+ *     const prices = [100, 80, 60, 70, 60, 75, 85];
+ *     const spans: number[] = [];
+ *     prices.forEach((price, i) => {
+ *       while (!stack.isEmpty() && prices[stack.peek()!] <= price) {
+ *         stack.pop();
+ *       }
+ *       spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);
+ *       stack.push(i);
+ *     });
+ *     console.log(spans); // [1, 1, 1, 2, 1, 4, 6]
  */
 export class Stack<E = any, R = any> extends IterableElementBase<E, R> {
   constructor(elements: Iterable<E> | Iterable<R> = [], options?: StackOptions<E, R>) {