queue-typed 1.54.2 → 2.0.0

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

@@ -4,8 +4,8 @@
  * @class
  */
 import type { ElementCallback, QueueOptions } from '../../types';
-import { IterableElementBase } from '../base';
 import { SinglyLinkedList } from '../linked-list';
+import { LinearBase } from '../base/linear-base';
 /**
  * 1. First In, First Out (FIFO): The core feature of a queue is its first in, first out nature. The element added to the queue first will be the one to be removed first.
  * 2. Operations: The main operations include enqueue (adding an element to the end of the queue) and dequeue (removing and returning the element at the front of the queue). Typically, there is also a peek operation (looking at the front element without removing it).
@@ -15,32 +15,23 @@ 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, R = any> extends IterableElementBase<E, R, Queue<E, R>> {
+export declare class Queue<E = any, R = any> extends LinearBase<E, R> {
     constructor(elements?: Iterable<E> | Iterable<R>, options?: QueueOptions<E, R>);
     protected _elements: E[];
-    /**
-     * The elements function returns the elements of this set.
-     * @return An array of the elements in the stack
-     */
     get elements(): E[];
     protected _offset: number;
-    /**
-     * The offset function returns the offset of the current page.
-     * @return The value of the protected variable _offset
-     */
     get offset(): number;
-    /**
-     * The size function returns the number of elements in an array.
-     * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
-     */
-    get size(): number;
+    get length(): number;
+    protected _autoCompactRatio: number;
+    get autoCompactRatio(): number;
+    set autoCompactRatio(v: number);
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
      * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
+     * the `_offset` index. If the data structure is empty (length is 0), it returns `undefined`.
      */
     get first(): E | undefined;
     /**
@@ -52,18 +43,6 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * array is empty, it returns `undefined`.
      */
     get last(): E | undefined;
-    protected _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)
@@ -122,7 +101,7 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * @param {number} index - Determine the index of the element to be deleted
      * @return A boolean value
      */
-    deleteAt(index: number): boolean;
+    deleteAt(index: number): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -135,22 +114,53 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * `_offset`.
      */
     at(index: number): E | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `reverse` function in TypeScript reverses the elements of an array starting from a specified
+     * offset.
+     * @returns The `reverse()` method is returning the modified object itself (`this`) after reversing
+     * the elements in the array and resetting the offset to 0.
+     */
+    reverse(): this;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `addAt` inserts a new element at a specified index in an array, returning true if
+     * successful and false if the index is out of bounds.
+     * @param {number} index - The `index` parameter represents the position at which the `newElement`
+     * should be added in the array.
+     * @param {E} newElement - The `newElement` parameter represents the element that you want to insert
+     * into the array at the specified index.
+     * @returns The `addAt` method returns a boolean value - `true` if the new element was successfully
+     * added at the specified index, and `false` if the index is out of bounds (less than 0 or greater
+     * than the length of the array).
+     */
+    addAt(index: number, newElement: E): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function checks if a data structure is empty by comparing its size to zero.
-     * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
+     * The function `setAt` updates an element at a specified index in an array-like data structure.
+     * @param {number} index - The `index` parameter is a number that represents the position in the
+     * array where the new element will be set.
+     * @param {E} newElement - The `newElement` parameter represents the new value that you want to set
+     * at the specified index in the array.
+     * @returns The `setAt` method returns a boolean value - `true` if the element was successfully set
+     * at the specified index, and `false` if the index is out of bounds (less than 0 or greater than the
+     * length of the array).
      */
-    isEmpty(): boolean;
+    setAt(index: number, newElement: E): boolean;
     /**
      * Time Complexity: O(1)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      *
-     * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
-     * @returns An array of type E is being returned.
+     * The function checks if a data structure is empty by comparing its length to zero.
+     * @returns {boolean} A boolean value indicating whether the length of the object is 0 or not.
      */
-    toArray(): E[];
+    isEmpty(): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -167,6 +177,25 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * @returns The `compact()` method is returning a boolean value of `true`.
      */
     compact(): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function overrides the splice method to remove and insert elements in a queue-like data
+     * structure.
+     * @param {number} start - The `start` parameter in the `splice` method specifies the index at which
+     * to start changing the array. Items will be added or removed starting from this index.
+     * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+     * number of elements to remove from the array starting at the specified `start` index. If
+     * `deleteCount` is not provided, it defaults to 0, meaning no elements will be removed but new
+     * elements can still be inserted at
+     * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+     * will be added to the array at the specified `start` index. These elements will replace the
+     * existing elements starting from the `start` index for the `deleteCount` number of elements.
+     * @returns The `splice` method is returning the `removedQueue`, which is an instance of the same
+     * class as the original object.
+     */
+    splice(start: number, deleteCount?: number, ...items: E[]): this;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -174,7 +203,7 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * 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, R>;
+    clone(): this;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -191,7 +220,7 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * @returns The `filter` method is returning a new `Queue` object that contains the elements that
      * satisfy the given predicate function.
      */
-    filter(predicate: ElementCallback<E, R, boolean, Queue<E, R>>, thisArg?: any): Queue<E, R>;
+    filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): Queue<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -210,7 +239,7 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * @returns A new Queue object containing elements of type EM, which are the result of applying the
      * callback function to each element in the original Queue object.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, Queue<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Queue<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Queue<EM, RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -218,6 +247,21 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * The function `_getIterator` returns an iterable iterator for the elements in the class.
      */
     protected _getIterator(): IterableIterator<E>;
+    /**
+     * The function `_createInstance` returns a new instance of the `Queue` class with the specified
+     * options.
+     * @param [options] - The `options` parameter in the `_createInstance` method is of type
+     * `QueueOptions<E, R>`, which is used to configure the behavior of the queue being created. It
+     * allows you to specify settings or properties that can influence how the queue operates.
+     * @returns An instance of the `Queue` class with an empty array and the provided options is being
+     * returned.
+     */
+    protected _createInstance(options?: QueueOptions<E, R>): this;
+    /**
+     * The function `_getReverseIterator` returns an iterator that iterates over elements in reverse
+     * order.
+     */
+    protected _getReverseIterator(): IterableIterator<E>;
 }
 /**
  * 1. First In, First Out (FIFO) Strategy: Like other queue implementations, LinkedListQueue follows the first in, first out principle, meaning the element that is added to the queue first will be the first to be removed.
@@ -234,5 +278,5 @@ export declare class LinkedListQueue<E = any, R = any> extends SinglyLinkedList<
      * @returns The `clone()` method is returning a new instance of `LinkedListQueue` with the same
      * values as the original `LinkedListQueue`.
      */
-    clone(): LinkedListQueue<E, R>;
+    clone(): this;
 }

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LinkedListQueue = exports.Queue = void 0;
-const base_1 = require("../base");
 const linked_list_1 = require("../linked-list");
+const linear_base_1 = require("../base/linear-base");
 /**
  * 1. First In, First Out (FIFO): The core feature of a queue is its first in, first out nature. The element added to the queue first will be the one to be removed first.
  * 2. Operations: The main operations include enqueue (adding an element to the end of the queue) and dequeue (removing and returning the element at the front of the queue). Typically, there is also a peek operation (looking at the front element without removing it).
@@ -12,7 +12,7 @@ const linked_list_1 = require("../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.
  */
-class Queue extends base_1.IterableElementBase {
+class Queue extends linear_base_1.LinearBase {
     constructor(elements = [], options) {
         super(options);
         this._elements = [];
@@ -24,37 +24,31 @@ class Queue extends base_1.IterableElementBase {
         }
         this.pushMany(elements);
     }
-    /**
-     * The elements function returns the elements of this set.
-     * @return An array of the elements in the stack
-     */
     get elements() {
         return this._elements;
     }
-    /**
-     * The offset function returns the offset of the current page.
-     * @return The value of the protected variable _offset
-     */
     get offset() {
         return this._offset;
     }
-    /**
-     * The size function returns the number of elements in an array.
-     * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
-     */
-    get size() {
+    get length() {
         return this.elements.length - this.offset;
     }
+    get autoCompactRatio() {
+        return this._autoCompactRatio;
+    }
+    set autoCompactRatio(v) {
+        this._autoCompactRatio = v;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
      * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
-     * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
+     * the `_offset` index. If the data structure is empty (length is 0), it returns `undefined`.
      */
     get first() {
-        return this.size > 0 ? this.elements[this.offset] : undefined;
+        return this.length > 0 ? this.elements[this.offset] : undefined;
     }
     /**
      * Time Complexity: O(1)
@@ -65,22 +59,7 @@ class Queue extends base_1.IterableElementBase {
      * array is empty, it returns `undefined`.
      */
     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;
+        return this.length > 0 ? this.elements[this.elements.length - 1] : undefined;
     }
     /**
      * Time Complexity: O(n)
@@ -105,6 +84,8 @@ class Queue extends base_1.IterableElementBase {
      */
     push(element) {
         this.elements.push(element);
+        if (this._maxLen > 0 && this.length > this._maxLen)
+            this.shift();
         return true;
     }
     /**
@@ -137,7 +118,7 @@ class Queue extends base_1.IterableElementBase {
      * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
      */
     shift() {
-        if (this.size === 0)
+        if (this.length === 0)
             return undefined;
         const first = this.first;
         this._offset += 1;
@@ -155,7 +136,7 @@ class Queue extends base_1.IterableElementBase {
      */
     delete(element) {
         const index = this.elements.indexOf(element);
-        return this.deleteAt(index);
+        return !!this.deleteAt(index);
     }
     /**
      * Time Complexity: O(n)
@@ -166,8 +147,9 @@ class Queue extends base_1.IterableElementBase {
      * @return A boolean value
      */
     deleteAt(index) {
-        const spliced = this.elements.splice(index, 1);
-        return spliced.length === 1;
+        const deleted = this.elements[index];
+        this.elements.splice(index, 1);
+        return deleted;
     }
     /**
      * Time Complexity: O(1)
@@ -183,25 +165,68 @@ class Queue extends base_1.IterableElementBase {
     at(index) {
         return this.elements[index + this._offset];
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `reverse` function in TypeScript reverses the elements of an array starting from a specified
+     * offset.
+     * @returns The `reverse()` method is returning the modified object itself (`this`) after reversing
+     * the elements in the array and resetting the offset to 0.
+     */
+    reverse() {
+        this._elements = this.elements.slice(this.offset).reverse();
+        this._offset = 0;
+        return this;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `addAt` inserts a new element at a specified index in an array, returning true if
+     * successful and false if the index is out of bounds.
+     * @param {number} index - The `index` parameter represents the position at which the `newElement`
+     * should be added in the array.
+     * @param {E} newElement - The `newElement` parameter represents the element that you want to insert
+     * into the array at the specified index.
+     * @returns The `addAt` method returns a boolean value - `true` if the new element was successfully
+     * added at the specified index, and `false` if the index is out of bounds (less than 0 or greater
+     * than the length of the array).
+     */
+    addAt(index, newElement) {
+        if (index < 0 || index > this.length)
+            return false;
+        this._elements.splice(this.offset + index, 0, newElement);
+        return true;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function checks if a data structure is empty by comparing its size to zero.
-     * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
+     * The function `setAt` updates an element at a specified index in an array-like data structure.
+     * @param {number} index - The `index` parameter is a number that represents the position in the
+     * array where the new element will be set.
+     * @param {E} newElement - The `newElement` parameter represents the new value that you want to set
+     * at the specified index in the array.
+     * @returns The `setAt` method returns a boolean value - `true` if the element was successfully set
+     * at the specified index, and `false` if the index is out of bounds (less than 0 or greater than the
+     * length of the array).
      */
-    isEmpty() {
-        return this.size === 0;
+    setAt(index, newElement) {
+        if (index < 0 || index > this.length)
+            return false;
+        this._elements[this.offset + index] = newElement;
+        return true;
     }
     /**
      * Time Complexity: O(1)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      *
-     * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
-     * @returns An array of type E is being returned.
+     * The function checks if a data structure is empty by comparing its length to zero.
+     * @returns {boolean} A boolean value indicating whether the length of the object is 0 or not.
      */
-    toArray() {
-        return this.elements.slice(this.offset);
+    isEmpty() {
+        return this.length === 0;
     }
     /**
      * Time Complexity: O(1)
@@ -226,6 +251,34 @@ class Queue extends base_1.IterableElementBase {
         this._offset = 0;
         return true;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function overrides the splice method to remove and insert elements in a queue-like data
+     * structure.
+     * @param {number} start - The `start` parameter in the `splice` method specifies the index at which
+     * to start changing the array. Items will be added or removed starting from this index.
+     * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+     * number of elements to remove from the array starting at the specified `start` index. If
+     * `deleteCount` is not provided, it defaults to 0, meaning no elements will be removed but new
+     * elements can still be inserted at
+     * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+     * will be added to the array at the specified `start` index. These elements will replace the
+     * existing elements starting from the `start` index for the `deleteCount` number of elements.
+     * @returns The `splice` method is returning the `removedQueue`, which is an instance of the same
+     * class as the original object.
+     */
+    splice(start, deleteCount = 0, ...items) {
+        const removedQueue = this._createInstance();
+        start = Math.max(0, Math.min(start, this.length));
+        deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+        const globalStartIndex = this.offset + start;
+        const removedElements = this._elements.splice(globalStartIndex, deleteCount, ...items);
+        removedQueue.pushMany(removedElements);
+        this.compact();
+        return removedQueue;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -234,7 +287,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), { toElementFn: this.toElementFn });
+        return new Queue(this.elements.slice(this.offset), { toElementFn: this.toElementFn, maxLen: this._maxLen });
     }
     /**
      * Time Complexity: O(n)
@@ -253,7 +306,11 @@ class Queue extends base_1.IterableElementBase {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-        const newDeque = new Queue([], { toElementFn: this.toElementFn });
+        const newDeque = this._createInstance({
+            toElementFn: this._toElementFn,
+            autoCompactRatio: this._autoCompactRatio,
+            maxLen: this._maxLen
+        });
         let index = 0;
         for (const el of this) {
             if (predicate.call(thisArg, el, index, this)) {
@@ -282,7 +339,11 @@ class Queue extends base_1.IterableElementBase {
      * callback function to each element in the original Queue object.
      */
     map(callback, toElementFn, thisArg) {
-        const newDeque = new Queue([], { toElementFn });
+        const newDeque = new Queue([], {
+            toElementFn,
+            autoCompactRatio: this._autoCompactRatio,
+            maxLen: this._maxLen
+        });
         let index = 0;
         for (const el of this) {
             newDeque.push(callback.call(thisArg, el, index, this));
@@ -301,6 +362,29 @@ class Queue extends base_1.IterableElementBase {
             yield item;
         }
     }
+    /**
+     * The function `_createInstance` returns a new instance of the `Queue` class with the specified
+     * options.
+     * @param [options] - The `options` parameter in the `_createInstance` method is of type
+     * `QueueOptions<E, R>`, which is used to configure the behavior of the queue being created. It
+     * allows you to specify settings or properties that can influence how the queue operates.
+     * @returns An instance of the `Queue` class with an empty array and the provided options is being
+     * returned.
+     */
+    _createInstance(options) {
+        return new Queue([], options);
+    }
+    /**
+     * The function `_getReverseIterator` returns an iterator that iterates over elements in reverse
+     * order.
+     */
+    *_getReverseIterator() {
+        for (let i = this.length - 1; i >= 0; i--) {
+            const cur = this.at(i); // `at()` handles the offset.
+            if (cur !== undefined)
+                yield cur;
+        }
+    }
 }
 exports.Queue = Queue;
 /**
@@ -319,7 +403,7 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
      * values as the original `LinkedListQueue`.
      */
     clone() {
-        return new LinkedListQueue(this, { toElementFn: this.toElementFn });
+        return new LinkedListQueue(this, { toElementFn: this.toElementFn, maxLen: this._maxLen });
     }
 }
 exports.LinkedListQueue = LinkedListQueue;

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

@@ -15,7 +15,7 @@ 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, R = any> extends IterableElementBase<E, R, Stack<E, R>> {
+export declare class Stack<E = any, R = any> extends IterableElementBase<E, R> {
     constructor(elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>);
     protected _elements: E[];
     /**
@@ -102,14 +102,6 @@ export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, S
      * @returns An array of type E.
      */
     deleteAt(index: number): boolean;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The toArray function returns a copy of the elements in an array.
-     * @returns An array of type E.
-     */
-    toArray(): E[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -141,7 +133,7 @@ export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, S
      * @returns The `filter` method is returning a new `Stack` object that contains the elements that
      * satisfy the given predicate function.
      */
-    filter(predicate: ElementCallback<E, R, boolean, Stack<E, R>>, thisArg?: any): Stack<E, R>;
+    filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): Stack<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -159,7 +151,7 @@ export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, S
      * 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>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Stack<EM, RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -136,16 +136,6 @@ class Stack extends base_1.IterableElementBase {
         const spliced = this.elements.splice(index, 1);
         return spliced.length === 1;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The toArray function returns a copy of the elements in an array.
-     * @returns An array of type E.
-     */
-    toArray() {
-        return this.elements.slice();
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -143,7 +143,7 @@ export declare class TrieNode {
  *     const subnet = ip.split('.').slice(0, 3).join('.');
  *     console.log(ipRoutingTable.hasPrefix(subnet)); // true
  */
-export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
+export declare class Trie<R = any> extends IterableElementBase<string, R> {
     /**
      * The constructor initializes a Trie data structure with optional options and words provided as
      * input.
@@ -311,7 +311,7 @@ export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R
      * 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, R, boolean, Trie<R>>, thisArg?: any): Trie<R>;
+    filter(predicate: ElementCallback<string, R, boolean>, thisArg?: any): Trie<R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -330,7 +330,7 @@ export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R
      * value of
      * @returns a new Trie object.
      */
-    map<RM>(callback: ElementCallback<string, R, string, Trie<R>>, toElementFn?: (rawElement: RM) => string, thisArg?: any): Trie<RM>;
+    map<RM>(callback: ElementCallback<string, R, string>, toElementFn?: (rawElement: RM) => string, thisArg?: any): Trie<RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -339,6 +339,7 @@ export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R
      * trie data structure and yields all the paths to the end nodes.
      */
     protected _getIterator(): IterableIterator<string>;
+    protected get _total(): number;
     /**
      * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.

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

@@ -573,6 +573,9 @@ class Trie extends base_1.IterableElementBase {
         }
         yield* _dfs(this.root, '');
     }
+    get _total() {
+        return this._size;
+    }
     /**
      * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.

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

@@ -1,8 +1,13 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
-export type EntryCallback<K, V, R> = (key: K, value: V, index: number, container: IterableEntryBase<K, 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<E, R, RT, C> = (accumulator: RT, element: E, index: number, container: IterableElementBase<E, R, C>) => RT;
+import { LinearBase } from '../../../data-structures/base/linear-base';
+export type EntryCallback<K, V, R> = (key: K, value: V, index: number, original: IterableEntryBase<K, V>) => R;
+export type ElementCallback<E, R, RT> = (element: E, index: number, original: IterableElementBase<E, R>) => RT;
+export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
+export type ReduceElementCallback<E, R, RT = E> = (accumulator: RT, element: E, index: number, original: IterableElementBase<E, R>) => RT;
+export type ReduceLinearCallback<E, RT = E> = (accumulator: RT, element: E, index: number, original: LinearBase<E>) => RT;
 export type IterableElementBaseOptions<E, R> = {
     toElementFn?: (rawElement: R) => E;
 };
+export type LinearBaseOptions<E, R> = IterableElementBaseOptions<E, R> & {
+    maxLen?: number;
+};

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

@@ -1,2 +1,2 @@
 import type { AVLTreeOptions } from './avl-tree';
-export type AVLTreeMultiMapOptions<K, V, R> = Omit<AVLTreeOptions<K, V, R>, 'isMapMode'> & {};
+export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};