red-black-tree-typed 2.2.2 → 2.2.3

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

@@ -60,431 +60,99 @@ export declare class DoublyLinkedListNode<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
- * // text editor operation history
- *     const actions = [
- *       { type: 'insert', content: 'first line of text' },
- *       { type: 'insert', content: 'second line of text' },
- *       { type: 'delete', content: 'delete the first line' }
- *     ];
- *     const editorHistory = new DoublyLinkedList<{ type: string; content: string }>(actions);
+ * // basic DoublyLinkedList creation and push operation
+ *  // Create a simple DoublyLinkedList with initial values
+ *     const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
  *
- *     console.log(editorHistory.last?.type); // 'delete'
- *     console.log(editorHistory.pop()?.content); // 'delete the first line'
- *     console.log(editorHistory.last?.type); // 'insert'
- * @example
- * // Browser history
- *     const browserHistory = new DoublyLinkedList<string>();
+ *     // Verify the list maintains insertion order
+ *     console.log([...list]); // [1, 2, 3, 4, 5];
  *
- *     browserHistory.push('home page');
- *     browserHistory.push('search page');
- *     browserHistory.push('details page');
+ *     // Check length
+ *     console.log(list.length); // 5;
  *
- *     console.log(browserHistory.last); // 'details page'
- *     console.log(browserHistory.pop()); // 'details page'
- *     console.log(browserHistory.last); // 'search page'
+ *     // Push a new element to the end
+ *     list.push(6);
+ *     console.log(list.length); // 6;
+ *     console.log([...list]); // [1, 2, 3, 4, 5, 6];
  * @example
- * // Use DoublyLinkedList to implement music player
- *     // Define the Song interface
- *     interface Song {
- *       title: string;
- *       artist: string;
- *       duration: number; // duration in seconds
- *     }
- *
- *     class Player {
- *       private playlist: DoublyLinkedList<Song>;
- *       private currentSong: ReturnType<typeof this.playlist.getNodeAt> | undefined;
- *
- *       constructor(songs: Song[]) {
- *         this.playlist = new DoublyLinkedList<Song>();
- *         songs.forEach(song => this.playlist.push(song));
- *         this.currentSong = this.playlist.head;
- *       }
- *
- *       // Play the next song in the playlist
- *       playNext(): Song | undefined {
- *         if (!this.currentSong?.next) {
- *           this.currentSong = this.playlist.head; // Loop to the first song
- *         } else {
- *           this.currentSong = this.currentSong.next;
- *         }
- *         return this.currentSong?.value;
- *       }
- *
- *       // Play the previous song in the playlist
- *       playPrevious(): Song | undefined {
- *         if (!this.currentSong?.prev) {
- *           this.currentSong = this.playlist.tail; // Loop to the last song
- *         } else {
- *           this.currentSong = this.currentSong.prev;
- *         }
- *         return this.currentSong?.value;
- *       }
- *
- *       // Get the current song
- *       getCurrentSong(): Song | undefined {
- *         return this.currentSong?.value;
- *       }
- *
- *       // Loop through the playlist twice
- *       loopThroughPlaylist(): Song[] {
- *         const playedSongs: Song[] = [];
- *         const initialNode = this.currentSong;
- *
- *         // Loop through the playlist twice
- *         for (let i = 0; i < this.playlist.length * 2; i++) {
- *           playedSongs.push(this.currentSong!.value);
- *           this.currentSong = this.currentSong!.next || this.playlist.head; // Loop back to the start if needed
- *         }
- *
- *         // Reset the current song to the initial song
- *         this.currentSong = initialNode;
- *         return playedSongs;
- *       }
- *     }
- *
- *     const songs = [
- *       { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 },
- *       { title: 'Hotel California', artist: 'Eagles', duration: 391 },
- *       { title: 'Shape of You', artist: 'Ed Sheeran', duration: 233 },
- *       { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 }
- *     ];
- *     let player = new Player(songs);
- *     // should play the next song
- *     player = new Player(songs);
- *     const firstSong = player.getCurrentSong();
- *     const nextSong = player.playNext();
- *
- *     // Expect the next song to be "Hotel California by Eagles"
- *     console.log(nextSong); // { title: 'Hotel California', artist: 'Eagles', duration: 391 }
- *     console.log(firstSong); // { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 }
- *
- *     // should play the previous song
- *     player = new Player(songs);
- *     player.playNext(); // Move to the second song
- *     const currentSong = player.getCurrentSong();
- *     const previousSong = player.playPrevious();
- *
- *     // Expect the previous song to be "Bohemian Rhapsody by Queen"
- *     console.log(previousSong); // { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 }
- *     console.log(currentSong); // { title: 'Hotel California', artist: 'Eagles', duration: 391 }
+ * // DoublyLinkedList pop and shift operations
+ *  const list = new DoublyLinkedList<number>([10, 20, 30, 40, 50]);
  *
- *     // should loop to the first song when playing next from the last song
- *     player = new Player(songs);
- *     player.playNext(); // Move to the second song
- *     player.playNext(); // Move to the third song
- *     player.playNext(); // Move to the fourth song
+ *     // Pop removes from the end
+ *     const last = list.pop();
+ *     console.log(last); // 50;
  *
- *     const nextSongToFirst = player.playNext(); // Should loop to the first song
+ *     // Shift removes from the beginning
+ *     const first = list.shift();
+ *     console.log(first); // 10;
  *
- *     // Expect the next song to be "Bohemian Rhapsody by Queen"
- *     console.log(nextSongToFirst); // { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 }
- *
- *     // should loop to the last song when playing previous from the first song
- *     player = new Player(songs);
- *     player.playNext(); // Move to the first song
- *     player.playNext(); // Move to the second song
- *     player.playNext(); // Move to the third song
- *     player.playNext(); // Move to the fourth song
- *
- *     const previousToLast = player.playPrevious(); // Should loop to the last song
- *
- *     // Expect the previous song to be "Billie Jean by Michael Jackson"
- *     console.log(previousToLast); // { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 }
- *
- *     // should loop through the entire playlist
- *     player = new Player(songs);
- *     const playedSongs = player.loopThroughPlaylist();
- *
- *     // The expected order of songs for two loops
- *     console.log(playedSongs); // [
- *  //      { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 },
- *  //      { title: 'Hotel California', artist: 'Eagles', duration: 391 },
- *  //      { title: 'Shape of You', artist: 'Ed Sheeran', duration: 233 },
- *  //      { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 },
- *  //      { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 },
- *  //      { title: 'Hotel California', artist: 'Eagles', duration: 391 },
- *  //      { title: 'Shape of You', artist: 'Ed Sheeran', duration: 233 },
- *  //      { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 }
- *  //    ]
+ *     // Verify remaining elements
+ *     console.log([...list]); // [20, 30, 40];
+ *     console.log(list.length); // 3;
  * @example
- * // Use DoublyLinkedList to implement LRU cache
- *     interface CacheEntry<K, V> {
- *       key: K;
- *       value: V;
- *     }
- *
- *     class LRUCache<K = string, V = any> {
- *       private readonly capacity: number;
- *       private list: DoublyLinkedList<CacheEntry<K, V>>;
- *       private map: Map<K, DoublyLinkedListNode<CacheEntry<K, V>>>;
- *
- *       constructor(capacity: number) {
- *         if (capacity <= 0) {
- *           throw new Error('lru cache capacity must be greater than 0');
- *         }
- *         this.capacity = capacity;
- *         this.list = new DoublyLinkedList<CacheEntry<K, V>>();
- *         this.map = new Map<K, DoublyLinkedListNode<CacheEntry<K, V>>>();
- *       }
- *
- *       // Get the current cache length
- *       get length(): number {
- *         return this.list.length;
- *       }
- *
- *       // Check if it is empty
- *       get isEmpty(): boolean {
- *         return this.list.isEmpty();
- *       }
- *
- *       // Get cached value
- *       get(key: K): V | undefined {
- *         const node = this.map.get(key);
- *
- *         if (!node) return undefined;
- *
- *         // Move the visited node to the head of the linked list (most recently used)
- *         this.moveToFront(node);
- *
- *         return node.value.value;
- *       }
- *
- *       // Set cache value
- *       set(key: K, value: V): void {
- *         // Check if it already exists
- *         const node = this.map.get(key);
- *
- *         if (node) {
- *           // Update value and move to head
- *           node.value.value = value;
- *           this.moveToFront(node);
- *           return;
- *         }
- *
- *         // Check capacity
- *         if (this.list.length >= this.capacity) {
- *           // Delete the least recently used element (the tail of the linked list)
- *           const removedNode = this.list.tail;
- *           if (removedNode) {
- *             this.map.delete(removedNode.value.key);
- *             this.list.pop();
- *           }
- *         }
- *
- *         // Create new node and add to head
- *         const newEntry: CacheEntry<K, V> = { key, value };
- *         this.list.unshift(newEntry);
+ * // DoublyLinkedList for...of iteration and map operation
+ *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
  *
- *         // Save node reference in map
- *         const newNode = this.list.head;
- *         if (newNode) {
- *           this.map.set(key, newNode);
- *         }
- *       }
+ *     // Iterate through list
+ *     const doubled = list.map(value => value * 2);
+ *     console.log(doubled.length); // 5;
  *
- *       // Delete specific key
- *       delete(key: K): boolean {
- *         const node = this.map.get(key);
- *         if (!node) return false;
- *
- *         // Remove from linked list
- *         this.list.delete(node);
- *         // Remove from map
- *         this.map.delete(key);
- *
- *         return true;
- *       }
- *
- *       // Clear cache
- *       clear(): void {
- *         this.list.clear();
- *         this.map.clear();
- *       }
- *
- *       // Move the node to the head of the linked list
- *       private moveToFront(node: DoublyLinkedListNode<CacheEntry<K, V>>): void {
- *         this.list.delete(node);
- *         this.list.unshift(node.value);
- *       }
+ *     // Use for...of loop
+ *     const result: number[] = [];
+ *     for (const item of list) {
+ *       result.push(item);
  *     }
- *
- *     // should set and get values correctly
- *     const cache = new LRUCache<string, number>(3);
- *     cache.set('a', 1);
- *     cache.set('b', 2);
- *     cache.set('c', 3);
- *
- *     console.log(cache.get('a')); // 1
- *     console.log(cache.get('b')); // 2
- *     console.log(cache.get('c')); // 3
- *
- *     // The least recently used element should be evicted when capacity is exceeded
- *     cache.clear();
- *     cache.set('a', 1);
- *     cache.set('b', 2);
- *     cache.set('c', 3);
- *     cache.set('d', 4); // This will eliminate 'a'
- *
- *     console.log(cache.get('a')); // undefined
- *     console.log(cache.get('b')); // 2
- *     console.log(cache.get('c')); // 3
- *     console.log(cache.get('d')); // 4
- *
- *     // The priority of an element should be updated when it is accessed
- *     cache.clear();
- *     cache.set('a', 1);
- *     cache.set('b', 2);
- *     cache.set('c', 3);
- *
- *     cache.get('a'); // access 'a'
- *     cache.set('d', 4); // This will eliminate 'b'
- *
- *     console.log(cache.get('a')); // 1
- *     console.log(cache.get('b')); // undefined
- *     console.log(cache.get('c')); // 3
- *     console.log(cache.get('d')); // 4
- *
- *     // Should support updating existing keys
- *     cache.clear();
- *     cache.set('a', 1);
- *     cache.set('a', 10);
- *
- *     console.log(cache.get('a')); // 10
- *
- *     // Should support deleting specified keys
- *     cache.clear();
- *     cache.set('a', 1);
- *     cache.set('b', 2);
- *
- *     console.log(cache.delete('a')); // true
- *     console.log(cache.get('a')); // undefined
- *     console.log(cache.length); // 1
- *
- *     // Should support clearing cache
- *     cache.clear();
- *     cache.set('a', 1);
- *     cache.set('b', 2);
- *     cache.clear();
- *
- *     console.log(cache.length); // 0
- *     console.log(cache.isEmpty); // true
+ *     console.log(result); // [1, 2, 3, 4, 5];
  * @example
- * // finding lyrics by timestamp in Coldplay's "Fix You"
- *     // Create a DoublyLinkedList to store song lyrics with timestamps
- *     const lyricsList = new DoublyLinkedList<{ time: number; text: string }>();
- *
- *     // Detailed lyrics with precise timestamps (in milliseconds)
- *     const lyrics = [
- *       { time: 0, text: "When you try your best, but you don't succeed" },
- *       { time: 4000, text: 'When you get what you want, but not what you need' },
- *       { time: 8000, text: "When you feel so tired, but you can't sleep" },
- *       { time: 12000, text: 'Stuck in reverse' },
- *       { time: 16000, text: 'And the tears come streaming down your face' },
- *       { time: 20000, text: "When you lose something you can't replace" },
- *       { time: 24000, text: 'When you love someone, but it goes to waste' },
- *       { time: 28000, text: 'Could it be worse?' },
- *       { time: 32000, text: 'Lights will guide you home' },
- *       { time: 36000, text: 'And ignite your bones' },
- *       { time: 40000, text: 'And I will try to fix you' }
- *     ];
- *
- *     // Populate the DoublyLinkedList with lyrics
- *     lyrics.forEach(lyric => lyricsList.push(lyric));
- *
- *     // Test different scenarios of lyric synchronization
- *
- *     // 1. Find lyric at exact timestamp
- *     const exactTimeLyric = lyricsList.getBackward(lyric => lyric.value.time <= 36000);
- *     console.log(exactTimeLyric?.text); // 'And ignite your bones'
- *
- *     // 2. Find lyric between timestamps
- *     const betweenTimeLyric = lyricsList.getBackward(lyric => lyric.value.time <= 22000);
- *     console.log(betweenTimeLyric?.text); // "When you lose something you can't replace"
+ * // Browser history
+ *  const browserHistory = new DoublyLinkedList<string>();
  *
- *     // 3. Find first lyric when timestamp is less than first entry
- *     const earlyTimeLyric = lyricsList.getBackward(lyric => lyric.value.time <= -1000);
- *     console.log(earlyTimeLyric); // undefined
+ *     browserHistory.push('home page');
+ *     browserHistory.push('search page');
+ *     browserHistory.push('details page');
  *
- *     // 4. Find last lyric when timestamp is after last entry
- *     const lateTimeLyric = lyricsList.getBackward(lyric => lyric.value.time <= 50000);
- *     console.log(lateTimeLyric?.text); // 'And I will try to fix you'
+ *     console.log(browserHistory.last); // 'details page';
+ *     console.log(browserHistory.pop()); // 'details page';
+ *     console.log(browserHistory.last); // 'search page';
  * @example
- * // cpu process schedules
- *     class Process {
- *       constructor(
- *         public id: number,
- *         public priority: number
- *       ) {}
- *
- *       execute(): string {
- *         return `Process ${this.id} executed.`;
- *       }
+ * // DoublyLinkedList for LRU cache implementation
+ *  interface CacheEntry {
+ *       key: string;
+ *       value: string;
  *     }
  *
- *     class Scheduler {
- *       private queue: DoublyLinkedList<Process>;
- *
- *       constructor() {
- *         this.queue = new DoublyLinkedList<Process>();
- *       }
- *
- *       addProcess(process: Process): void {
- *         // Insert processes into a queue based on priority, keeping priority in descending order
- *         let current = this.queue.head;
- *         while (current && current.value.priority >= process.priority) {
- *           current = current.next;
- *         }
- *
- *         if (!current) {
- *           this.queue.push(process);
- *         } else {
- *           this.queue.addBefore(current, process);
- *         }
- *       }
- *
- *       executeNext(): string | undefined {
- *         // Execute tasks at the head of the queue in order
- *         const process = this.queue.shift();
- *         return process ? process.execute() : undefined;
- *       }
- *
- *       listProcesses(): string[] {
- *         return this.queue.toArray().map(process => `Process ${process.id} (Priority: ${process.priority})`);
- *       }
- *
- *       clear(): void {
- *         this.queue.clear();
- *       }
+ *     // Simulate LRU cache using DoublyLinkedList
+ *     // DoublyLinkedList is perfect because:
+ *     // - O(1) delete from any position
+ *     // - O(1) push to end
+ *     // - Bidirectional traversal for LRU policy
+ *
+ *     const cacheList = new DoublyLinkedList<CacheEntry>();
+ *     const maxSize = 3;
+ *
+ *     // Add cache entries
+ *     cacheList.push({ key: 'user:1', value: 'Alice' });
+ *     cacheList.push({ key: 'user:2', value: 'Bob' });
+ *     cacheList.push({ key: 'user:3', value: 'Charlie' });
+ *
+ *     // Try to add a new entry when cache is full
+ *     if (cacheList.length >= maxSize) {
+ *       // Remove the oldest (first) entry
+ *       const evicted = cacheList.shift();
+ *       console.log(evicted?.key); // 'user:1';
  *     }
  *
- *     // should add processes based on priority
- *     let scheduler = new Scheduler();
- *     scheduler.addProcess(new Process(1, 10));
- *     scheduler.addProcess(new Process(2, 20));
- *     scheduler.addProcess(new Process(3, 15));
- *
- *     console.log(scheduler.listProcesses()); // [
- *  //      'Process 2 (Priority: 20)',
- *  //      'Process 3 (Priority: 15)',
- *  //      'Process 1 (Priority: 10)'
- *  //    ]
- *
- *     // should execute the highest priority process
- *     scheduler = new Scheduler();
- *     scheduler.addProcess(new Process(1, 10));
- *     scheduler.addProcess(new Process(2, 20));
- *
- *     console.log(scheduler.executeNext()); // 'Process 2 executed.'
- *     console.log(scheduler.listProcesses()); // ['Process 1 (Priority: 10)']
+ *     // Add new entry
+ *     cacheList.push({ key: 'user:4', value: 'Diana' });
  *
- *     // should clear all processes
- *     scheduler = new Scheduler();
- *     scheduler.addProcess(new Process(1, 10));
- *     scheduler.addProcess(new Process(2, 20));
+ *     // Verify current cache state
+ *     console.log(cacheList.length); // 3;
+ *     const cachedKeys = [...cacheList].map(entry => entry.key);
+ *     console.log(cachedKeys); // ['user:2', 'user:3', 'user:4'];
  *
- *     scheduler.clear();
- *     console.log(scheduler.listProcesses()); // []
+ *     // Access entry (in real LRU, this would move it to end)
+ *     const foundEntry = [...cacheList].find(entry => entry.key === 'user:2');
+ *     console.log(foundEntry?.value); // 'Bob';
  */
 export declare class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, DoublyLinkedListNode<E>> {
     protected _equals: (a: E, b: E) => boolean;

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

@@ -46,8 +46,124 @@ 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
+ * // basic SinglyLinkedList creation and push operation
+ *  // Create a simple SinglyLinkedList with initial values
+ *     const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+ *
+ *     // Verify the list maintains insertion order
+ *     console.log([...list]); // [1, 2, 3, 4, 5];
+ *
+ *     // Check length
+ *     console.log(list.length); // 5;
+ *
+ *     // Push a new element to the end
+ *     list.push(6);
+ *     console.log(list.length); // 6;
+ *     console.log([...list]); // [1, 2, 3, 4, 5, 6];
+ * @example
+ * // SinglyLinkedList pop and shift operations
+ *  const list = new SinglyLinkedList<number>([10, 20, 30, 40, 50]);
+ *
+ *     // Pop removes from the end
+ *     const last = list.pop();
+ *     console.log(last); // 50;
+ *
+ *     // Shift removes from the beginning
+ *     const first = list.shift();
+ *     console.log(first); // 10;
+ *
+ *     // Verify remaining elements
+ *     console.log([...list]); // [20, 30, 40];
+ *     console.log(list.length); // 3;
+ * @example
+ * // SinglyLinkedList unshift and forward traversal
+ *  const list = new SinglyLinkedList<number>([20, 30, 40]);
+ *
+ *     // Unshift adds to the beginning
+ *     list.unshift(10);
+ *     console.log([...list]); // [10, 20, 30, 40];
+ *
+ *     // Access elements (forward traversal only for singly linked)
+ *     const second = list.at(1);
+ *     console.log(second); // 20;
+ *
+ *     // SinglyLinkedList allows forward iteration only
+ *     const elements: number[] = [];
+ *     for (const item of list) {
+ *       elements.push(item);
+ *     }
+ *     console.log(elements); // [10, 20, 30, 40];
+ *
+ *     console.log(list.length); // 4;
+ * @example
+ * // SinglyLinkedList filter and map operations
+ *  const list = new SinglyLinkedList<number>([1, 2, 3, 4, 5]);
+ *
+ *     // Filter even numbers
+ *     const filtered = list.filter(value => value % 2 === 0);
+ *     console.log(filtered.length); // 2;
+ *
+ *     // Map to double values
+ *     const doubled = list.map(value => value * 2);
+ *     console.log(doubled.length); // 5;
+ *
+ *     // Use reduce to sum
+ *     const sum = list.reduce((acc, value) => acc + value, 0);
+ *     console.log(sum); // 15;
+ * @example
+ * // SinglyLinkedList for sequentially processed data stream
+ *  interface LogEntry {
+ *       timestamp: number;
+ *       level: 'INFO' | 'WARN' | 'ERROR';
+ *       message: string;
+ *     }
+ *
+ *     // SinglyLinkedList is ideal for sequential processing where you only need forward iteration
+ *     // O(1) insertion/deletion at head, O(n) for tail operations
+ *     const logStream = new SinglyLinkedList<LogEntry>();
+ *
+ *     // Simulate incoming log entries
+ *     const entries: LogEntry[] = [
+ *       { timestamp: 1000, level: 'INFO', message: 'Server started' },
+ *       { timestamp: 1100, level: 'WARN', message: 'Memory usage high' },
+ *       { timestamp: 1200, level: 'ERROR', message: 'Connection failed' },
+ *       { timestamp: 1300, level: 'INFO', message: 'Connection restored' }
+ *     ];
+ *
+ *     // Add entries to the stream
+ *     for (const entry of entries) {
+ *       logStream.push(entry);
+ *     }
+ *
+ *     console.log(logStream.length); // 4;
+ *
+ *     // Process logs sequentially (only forward iteration needed)
+ *     const processedLogs: string[] = [];
+ *     for (const log of logStream) {
+ *       processedLogs.push(`[${log.level}] ${log.message}`);
+ *     }
+ *
+ *     console.log(processedLogs); // [
+ *  //      '[INFO] Server started',
+ *  //      '[WARN] Memory usage high',
+ *  //      '[ERROR] Connection failed',
+ *  //      '[INFO] Connection restored'
+ *  //    ];
+ *
+ *     // Get first log (O(1) - direct head access)
+ *     const firstLog = logStream.at(0);
+ *     console.log(firstLog?.message); // 'Server started';
+ *
+ *     // Remove oldest log (O(1) operation at head)
+ *     const removed = logStream.shift();
+ *     console.log(removed?.message); // 'Server started';
+ *     console.log(logStream.length); // 3;
+ *
+ *     // Remaining logs still maintain order for sequential processing
+ *     console.log(logStream.length); // 3;
+ * @example
  * // implementation of a basic text editor
- *     class TextEditor {
+ *  class TextEditor {
  *       private content: SinglyLinkedList<string>;
  *       private cursorIndex: number;
  *       private undoStack: Stack<{ operation: string; data?: any }>;
@@ -100,17 +216,17 @@ export declare class SinglyLinkedListNode<E = any> extends LinkedListNode<E> {
  *     editor.insert('l');
  *     editor.insert('l');
  *     editor.insert('o');
- *     console.log(editor.getText()); // 'Hello' // Output: "Hello"
+ *     console.log(editor.getText()); // 'Hello'; // Output: "Hello"
  *
  *     editor.delete();
- *     console.log(editor.getText()); // 'Hell' // Output: "Hell"
+ *     console.log(editor.getText()); // 'Hell'; // Output: "Hell"
  *
  *     editor.undo();
- *     console.log(editor.getText()); // 'Hello' // Output: "Hello"
+ *     console.log(editor.getText()); // 'Hello'; // Output: "Hello"
  *
  *     editor.moveCursor(1);
  *     editor.insert('a');
- *     console.log(editor.getText()); // 'Haello'
+ *     console.log(editor.getText()); // 'Haello';
  */
 export declare class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, SinglyLinkedListNode<E>> {
     protected _equals: (a: E, b: E) => boolean;