bst-typed 1.51.9 → 1.52.0

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

@@ -5,9 +5,9 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { PriorityQueueOptions } from '../../types';
+import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
-export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
+export declare class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a
      * comparator function.
@@ -15,9 +15,55 @@ export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
      * elements to be added to the priority queue. It is optional and defaults to an empty array if not
      * provided.
      * @param options - The `options` parameter is an object that contains additional configuration
-     * options for the priority queue. In this case, it has a property called `comparator` which is a
+     * options for the priority queue. In this case, it has a property called `comparator,` which is a
      * function used to compare elements in the priority queue. The `comparator` function takes two
-     * parameters `a` and `b`,
+     * parameters `a` and `b`
      */
-    constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>);
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: PriorityQueueOptions<E, R>);
+    /**
+     * The `clone` function returns a new instance of the `MinPriorityQueue` class with the same
+     * comparator and toElementFn as the original instance.
+     * @returns The method is returning a new instance of the `MinPriorityQueue` class with the same
+     * properties as the current instance.
+     */
+    clone(): MinPriorityQueue<E, R>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new MinPriorityQueue object containing elements that pass a given callback
+     * function.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: the current element, the index of the current element, and the
+     * heap itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `MinPriorityQueue` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback: ElementCallback<E, R, boolean, MinPriorityQueue<E, R>>, thisArg?: any): MinPriorityQueue<E, R>;
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new heap by applying a callback function to each element of the
+     * original heap.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
+     * element), and `this` (the heap itself). The callback function should return a value of
+     * @param comparator - The `comparator` parameter is a function that defines the order of the
+     * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
+     * if `a` should be placed before `b`, a positive number if `a` should be placed after
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
+     * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
+     * returns a value of type `T`. This function is used to transform the elements of the original
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new instance of the `MinPriorityQueue` class with the mapped elements.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM, MinPriorityQueue<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MinPriorityQueue<EM, RM>;
 }

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

@@ -10,21 +10,81 @@ class MinPriorityQueue extends priority_queue_1.PriorityQueue {
      * elements to be added to the priority queue. It is optional and defaults to an empty array if not
      * provided.
      * @param options - The `options` parameter is an object that contains additional configuration
-     * options for the priority queue. In this case, it has a property called `comparator` which is a
+     * options for the priority queue. In this case, it has a property called `comparator,` which is a
      * function used to compare elements in the priority queue. The `comparator` function takes two
-     * parameters `a` and `b`,
+     * parameters `a` and `b`
      */
-    constructor(elements = [], options = {
-        comparator: (a, b) => {
-            if (!(typeof a === 'number' && typeof b === 'number')) {
-                throw new Error('The a, b params of compare function must be number');
-            }
-            else {
-                return a - b;
+    constructor(elements = [], options) {
+        super(elements, options);
+    }
+    /**
+     * The `clone` function returns a new instance of the `MinPriorityQueue` class with the same
+     * comparator and toElementFn as the original instance.
+     * @returns The method is returning a new instance of the `MinPriorityQueue` class with the same
+     * properties as the current instance.
+     */
+    clone() {
+        return new MinPriorityQueue(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new MinPriorityQueue object containing elements that pass a given callback
+     * function.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: the current element, the index of the current element, and the
+     * heap itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `MinPriorityQueue` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+        const filteredPriorityQueue = new MinPriorityQueue([], {
+            toElementFn: this.toElementFn,
+            comparator: this.comparator
+        });
+        let index = 0;
+        for (const current of this) {
+            if (callback.call(thisArg, current, index, this)) {
+                filteredPriorityQueue.add(current);
             }
+            index++;
         }
-    }) {
-        super(elements, options);
+        return filteredPriorityQueue;
+    }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new heap by applying a callback function to each element of the
+     * original heap.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
+     * element), and `this` (the heap itself). The callback function should return a value of
+     * @param comparator - The `comparator` parameter is a function that defines the order of the
+     * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
+     * if `a` should be placed before `b`, a positive number if `a` should be placed after
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
+     * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
+     * returns a value of type `T`. This function is used to transform the elements of the original
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new instance of the `MinPriorityQueue` class with the mapped elements.
+     */
+    map(callback, comparator, toElementFn, thisArg) {
+        const mappedPriorityQueue = new MinPriorityQueue([], { comparator, toElementFn });
+        let index = 0;
+        for (const el of this) {
+            mappedPriorityQueue.add(callback.call(thisArg, el, index, this));
+            index++;
+        }
+        return mappedPriorityQueue;
     }
 }
 exports.MinPriorityQueue = MinPriorityQueue;

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { PriorityQueueOptions } from '../../types';
+import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { Heap } from '../heap';
 /**
  * 1. Element Priority: In a PriorityQueue, elements are sorted according to their priority. Each dequeue (element removal) operation removes the element with the highest priority. The priority can be determined based on the natural ordering of the elements or through a provided comparator (Comparator).
@@ -15,14 +15,60 @@ import { Heap } from '../heap';
  * 5. Huffman Coding: Used to select the smallest node combination when constructing a Huffman tree.
  * 6. Kth Largest Element in a Data Stream: Used to maintain a min-heap of size K for quickly finding the Kth largest element in stream data
  */
-export declare class PriorityQueue<E = any> extends Heap<E> {
+export declare class PriorityQueue<E = any, R = any> extends Heap<E, R> {
     /**
      * The constructor initializes a priority queue with optional elements and options.
      * @param elements - The `elements` parameter is an iterable object that contains the initial
-     * elements to be added to the priority queue. It is an optional parameter and if not provided, the
+     * elements to be added to the priority queue. It is an optional parameter, and if not provided, the
      * priority queue will be initialized as empty.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the priority queue. It can contain the following properties:
      */
-    constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>);
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: PriorityQueueOptions<E, R>);
+    /**
+     * The `clone` function returns a new instance of the `PriorityQueue` class with the same comparator
+     * and toElementFn as the original instance.
+     * @returns The method is returning a new instance of the `PriorityQueue` class with the same
+     * elements and properties as the current instance.
+     */
+    clone(): PriorityQueue<E, R>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new PriorityQueue object containing elements that pass a given callback
+     * function.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: the current element, the index of the current element, and the
+     * heap itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `PriorityQueue` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback: ElementCallback<E, R, boolean, PriorityQueue<E, R>>, thisArg?: any): PriorityQueue<E, R>;
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new heap by applying a callback function to each element of the
+     * original heap.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
+     * element), and `this` (the heap itself). The callback function should return a value of
+     * @param comparator - The `comparator` parameter is a function that defines the order of the
+     * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
+     * if `a` should be placed before `b`, a positive number if `a` should be placed after
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
+     * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
+     * returns a value of type `T`. This function is used to transform the elements of the original
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new instance of the `PriorityQueue` class with the mapped elements.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM, PriorityQueue<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): PriorityQueue<EM, RM>;
 }

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

@@ -14,7 +14,7 @@ class PriorityQueue extends heap_1.Heap {
     /**
      * The constructor initializes a priority queue with optional elements and options.
      * @param elements - The `elements` parameter is an iterable object that contains the initial
-     * elements to be added to the priority queue. It is an optional parameter and if not provided, the
+     * elements to be added to the priority queue. It is an optional parameter, and if not provided, the
      * priority queue will be initialized as empty.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the priority queue. It can contain the following properties:
@@ -22,5 +22,74 @@ class PriorityQueue extends heap_1.Heap {
     constructor(elements = [], options) {
         super(elements, options);
     }
+    /**
+     * The `clone` function returns a new instance of the `PriorityQueue` class with the same comparator
+     * and toElementFn as the original instance.
+     * @returns The method is returning a new instance of the `PriorityQueue` class with the same
+     * elements and properties as the current instance.
+     */
+    clone() {
+        return new PriorityQueue(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new PriorityQueue object containing elements that pass a given callback
+     * function.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: the current element, the index of the current element, and the
+     * heap itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `PriorityQueue` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+        const filteredPriorityQueue = new PriorityQueue([], {
+            toElementFn: this.toElementFn,
+            comparator: this.comparator
+        });
+        let index = 0;
+        for (const current of this) {
+            if (callback.call(thisArg, current, index, this)) {
+                filteredPriorityQueue.add(current);
+            }
+            index++;
+        }
+        return filteredPriorityQueue;
+    }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new heap by applying a callback function to each element of the
+     * original heap.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
+     * element), and `this` (the heap itself). The callback function should return a value of
+     * @param comparator - The `comparator` parameter is a function that defines the order of the
+     * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
+     * if `a` should be placed before `b`, a positive number if `a` should be placed after
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
+     * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
+     * returns a value of type `T`. This function is used to transform the elements of the original
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new instance of the `PriorityQueue` class with the mapped elements.
+     */
+    map(callback, comparator, toElementFn, thisArg) {
+        const mappedPriorityQueue = new PriorityQueue([], { comparator, toElementFn });
+        let index = 0;
+        for (const el of this) {
+            mappedPriorityQueue.add(callback.call(thisArg, el, index, this));
+            index++;
+        }
+        return mappedPriorityQueue;
+    }
 }
 exports.PriorityQueue = PriorityQueue;

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

@@ -14,9 +14,9 @@ import { IterableElementBase } from '../base';
  * 4. Efficiency: Adding and removing elements at both ends of a deque is usually very fast. However, when the dynamic array needs to expand, it may involve copying the entire array to a larger one, and this operation has a time complexity of O(n).
  * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
  */
-export declare class Deque<E> extends IterableElementBase<E> {
+export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E, R>> {
     /**
-     * The constructor initializes a Deque object with an optional iterable of elements and options.
+     * The constructor initializes a Deque object with optional iterable of elements and options.
      * @param elements - An iterable object (such as an array or a Set) that contains the initial
      * elements to be added to the deque. It can also be an object with a `length` or `size` property
      * that represents the number of elements in the iterable object. If no elements are provided, an
@@ -26,7 +26,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * which determines the size of each bucket in the deque. If the `bucketSize` option is not provided
      * or is not a number
      */
-    constructor(elements?: IterableWithSizeOrLength<E>, options?: DequeOptions);
+    constructor(elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>, options?: DequeOptions<E, R>);
     protected _bucketSize: number;
     /**
      * The bucketSize function returns the size of the bucket.
@@ -392,7 +392,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * @returns The `clone()` method is returning a new instance of the `Deque` class with the same
      * elements as the original deque (`this`) and the same bucket size.
      */
-    clone(): Deque<E>;
+    clone(): Deque<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -413,25 +413,27 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * @returns The `filter` method is returning a new `Deque` object that contains the elements that
      * satisfy the given predicate function.
      */
-    filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Deque<E>;
+    filter(predicate: ElementCallback<E, R, boolean, Deque<E, R>>, thisArg?: any): Deque<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new Deque by applying a callback function to each element of the
-     * original Deque.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the deque. It takes three arguments:
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns a new Deque object with the mapped values.
-     */
-    map<T>(callback: ElementCallback<E, T>, thisArg?: any): Deque<T>;
+     * The `map` function takes a callback function and applies it to each element in the deque,
+     * returning a new deque with the results.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * deque. It takes three arguments: the current element, the index of the element, and the deque
+     * itself. It should return a value of type EM.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * transform the raw element (`RM`) into a new element (`EM`) before adding it to the new deque. If
+     * provided, this function will be called for each raw element in the original deque.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new Deque object with elements of type EM and raw elements of type RM.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM, Deque<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Deque<EM, RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

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

@@ -12,7 +12,7 @@ const utils_1 = require("../../utils");
  */
 class Deque extends base_1.IterableElementBase {
     /**
-     * The constructor initializes a Deque object with an optional iterable of elements and options.
+     * The constructor initializes a Deque object with optional iterable of elements and options.
      * @param elements - An iterable object (such as an array or a Set) that contains the initial
      * elements to be added to the deque. It can also be an object with a `length` or `size` property
      * that represents the number of elements in the iterable object. If no elements are provided, an
@@ -23,7 +23,7 @@ class Deque extends base_1.IterableElementBase {
      * or is not a number
      */
     constructor(elements = [], options) {
-        super();
+        super(options);
         this._bucketSize = 1 << 12;
         this._bucketFirst = 0;
         this._firstInBucket = 0;
@@ -57,8 +57,13 @@ class Deque extends base_1.IterableElementBase {
         const needBucketNum = (0, utils_1.calcMinUnitsRequired)(_size, this._bucketSize);
         this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
         this._firstInBucket = this._lastInBucket = (this._bucketSize - (_size % this._bucketSize)) >> 1;
-        for (const element of elements) {
-            this.push(element);
+        for (const el of elements) {
+            if (this.toElementFn) {
+                this.push(this.toElementFn(el));
+            }
+            else {
+                this.push(el);
+            }
         }
     }
     /**
@@ -708,7 +713,7 @@ class Deque extends base_1.IterableElementBase {
      * elements as the original deque (`this`) and the same bucket size.
      */
     clone() {
-        return new Deque([...this], { bucketSize: this.bucketSize });
+        return new Deque(this, { bucketSize: this.bucketSize, toElementFn: this.toElementFn });
     }
     /**
      * Time Complexity: O(n)
@@ -731,7 +736,7 @@ class Deque extends base_1.IterableElementBase {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-        const newDeque = new Deque([], { bucketSize: this._bucketSize });
+        const newDeque = new Deque([], { bucketSize: this._bucketSize, toElementFn: this.toElementFn });
         let index = 0;
         for (const el of this) {
             if (predicate.call(thisArg, el, index, this)) {
@@ -746,20 +751,22 @@ class Deque extends base_1.IterableElementBase {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new Deque by applying a callback function to each element of the
-     * original Deque.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the deque. It takes three arguments:
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns a new Deque object with the mapped values.
-     */
-    map(callback, thisArg) {
-        const newDeque = new Deque([], { bucketSize: this._bucketSize });
+     * The `map` function takes a callback function and applies it to each element in the deque,
+     * returning a new deque with the results.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * deque. It takes three arguments: the current element, the index of the element, and the deque
+     * itself. It should return a value of type EM.
+     * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+     * transform the raw element (`RM`) into a new element (`EM`) before adding it to the new deque. If
+     * provided, this function will be called for each raw element in the original deque.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used to set the context or scope
+     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+     * value of
+     * @returns a new Deque object with elements of type EM and raw elements of type RM.
+     */
+    map(callback, toElementFn, thisArg) {
+        const newDeque = new Deque([], { bucketSize: this._bucketSize, toElementFn });
         let index = 0;
         for (const el of this) {
             newDeque.push(callback.call(thisArg, el, index, this));

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

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