data-structure-typed 1.33.0 → 1.33.5

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

@@ -5,81 +5,81 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export declare class SinglyLinkedListNode<T = number> {
+export declare class SinglyLinkedListNode<E = any> {
     /**
      * The constructor function initializes an instance of a class with a given value and sets the next property to null.
-     * @param {T} val - The "val" parameter is of type T, which means it can be any data type. It represents the value that
+     * @param {E} val - The "val" parameter is of type E, which means it can be any data type. It represents the value that
      * will be stored in the node of a linked list.
      */
-    constructor(val: T);
+    constructor(val: E);
     private _val;
-    get val(): T;
-    set val(value: T);
+    get val(): E;
+    set val(value: E);
     private _next;
-    get next(): SinglyLinkedListNode<T> | null;
-    set next(value: SinglyLinkedListNode<T> | null);
+    get next(): SinglyLinkedListNode<E> | null;
+    set next(value: SinglyLinkedListNode<E> | null);
 }
-export declare class SinglyLinkedList<T = any> {
+export declare class SinglyLinkedList<E = any> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor();
     private _head;
-    get head(): SinglyLinkedListNode<T> | null;
-    set head(value: SinglyLinkedListNode<T> | null);
+    get head(): SinglyLinkedListNode<E> | null;
+    set head(value: SinglyLinkedListNode<E> | null);
     private _tail;
-    get tail(): SinglyLinkedListNode<T> | null;
-    set tail(value: SinglyLinkedListNode<T> | null);
+    get tail(): SinglyLinkedListNode<E> | null;
+    set tail(value: SinglyLinkedListNode<E> | null);
     private _length;
     get length(): number;
     /**
      * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
      * array.
-     * @param {T[]} data - The `data` parameter is an array of elements of type `T`.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
      * @returns The `fromArray` function returns a `SinglyLinkedList` object.
      */
-    static fromArray<T>(data: T[]): SinglyLinkedList<T>;
+    static fromArray<E>(data: E[]): SinglyLinkedList<E>;
     getLength(): number;
     /**
      * The `push` function adds a new node with the given data to the end of a singly linked list.
-     * @param {T} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
-     * any type (T) as specified in the generic type declaration of the class or function.
+     * @param {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * any type (E) as specified in the generic type declaration of the class or function.
      */
-    push(data: T): void;
+    push(data: E): void;
     /**
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
      * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
      * the linked list is empty, it returns `null`.
      */
-    pop(): T | undefined;
+    pop(): E | undefined;
     /**
      * The `shift()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
      */
-    shift(): T | undefined;
+    shift(): E | undefined;
     /**
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
-     * @param {T} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+     * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
      * linked list.
      */
-    unshift(val: T): void;
+    unshift(val: E): void;
     /**
      * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
      * retrieve from the list.
-     * @returns The method `getAt(index: number): T | null` returns the value at the specified index in the linked list, or
+     * @returns The method `getAt(index: number): E | null` returns the value at the specified index in the linked list, or
      * `null` if the index is out of bounds.
      */
-    getAt(index: number): T | undefined;
+    getAt(index: number): E | undefined;
     /**
      * The function `getNodeAt` returns the node at a given index in a singly linked list.
      * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
      * retrieve from the linked list. It indicates the zero-based index of the node we want to access.
-     * @returns The method `getNodeAt(index: number)` returns a `SinglyLinkedListNode<T>` object if the node at the
+     * @returns The method `getNodeAt(index: number)` returns a `SinglyLinkedListNode<E>` object if the node at the
      * specified index exists, or `null` if the index is out of bounds.
      */
-    getNodeAt(index: number): SinglyLinkedListNode<T> | null;
+    getNodeAt(index: number): SinglyLinkedListNode<E> | null;
     /**
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
@@ -87,19 +87,19 @@ export declare class SinglyLinkedList<T = any> {
      * @returns The method `deleteAt` returns the value of the node that was deleted, or `null` if the index is out of
      * bounds.
      */
-    deleteAt(index: number): T | undefined;
-    delete(valueOrNode: T): boolean;
-    delete(valueOrNode: SinglyLinkedListNode<T>): boolean;
+    deleteAt(index: number): E | undefined;
+    delete(valueOrNode: E): boolean;
+    delete(valueOrNode: SinglyLinkedListNode<E>): boolean;
     /**
      * The `insertAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
      * linked list. It is of type number.
-     * @param {T} val - The `val` parameter represents the value that you want to insert into the linked list at the
+     * @param {E} val - The `val` parameter represents the value that you want to insert into the linked list at the
      * specified index.
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insertAt(index: number, val: T): boolean;
+    insertAt(index: number, val: E): boolean;
     /**
      * The function checks if the length of a data structure is equal to zero and returns a boolean value indicating
      * whether it is empty or not.
@@ -112,9 +112,9 @@ export declare class SinglyLinkedList<T = any> {
     clear(): void;
     /**
      * The `toArray` function converts a linked list into an array.
-     * @returns The `toArray()` method is returning an array of type `T[]`.
+     * @returns The `toArray()` method is returning an array of type `E[]`.
      */
-    toArray(): T[];
+    toArray(): E[];
     /**
      * The `reverse` function reverses the order of the nodes in a singly linked list.
      * @returns The reverse() method does not return anything. It has a return type of void.
@@ -122,36 +122,36 @@ export declare class SinglyLinkedList<T = any> {
     reverse(): void;
     /**
      * The `find` function iterates through a linked list and returns the first element that satisfies a given condition.
-     * @param callback - A function that takes a value of type T as its parameter and returns a boolean value. This
+     * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a particular value in the linked list satisfies a certain condition.
      * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
      * the callback function. If no element satisfies the condition, it returns `null`.
      */
-    find(callback: (val: T) => boolean): T | null;
+    find(callback: (val: E) => boolean): E | null;
     /**
      * The `indexOf` function returns the index of the first occurrence of a given value in a linked list.
-     * @param {T} value - The value parameter is the value that you want to find the index of in the linked list.
+     * @param {E} value - The value parameter is the value that you want to find the index of in the linked list.
      * @returns The method is returning the index of the first occurrence of the specified value in the linked list. If the
      * value is not found, it returns -1.
      */
-    indexOf(value: T): number;
+    indexOf(value: E): number;
     /**
      * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
      * null.
-     * @param {T} value - The value parameter is the value that we want to search for in the linked list.
-     * @returns a `SinglyLinkedListNode<T>` if a node with the specified value is found in the linked list. If no node with
+     * @param {E} value - The value parameter is the value that we want to search for in the linked list.
+     * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
      * the specified value is found, the function returns `null`.
      */
-    findNode(value: T): SinglyLinkedListNode<T> | null;
-    insertBefore(existingValue: T, newValue: T): boolean;
-    insertBefore(existingValue: SinglyLinkedListNode<T>, newValue: T): boolean;
-    insertAfter(existingValueOrNode: T, newValue: T): boolean;
-    insertAfter(existingValueOrNode: SinglyLinkedListNode<T>, newValue: T): boolean;
+    findNode(value: E): SinglyLinkedListNode<E> | null;
+    insertBefore(existingValue: E, newValue: E): boolean;
+    insertBefore(existingValue: SinglyLinkedListNode<E>, newValue: E): boolean;
+    insertAfter(existingValueOrNode: E, newValue: E): boolean;
+    insertAfter(existingValueOrNode: SinglyLinkedListNode<E>, newValue: E): boolean;
     /**
      * The function counts the number of occurrences of a given value in a linked list.
-     * @param {T} value - The value parameter is the value that you want to count the occurrences of in the linked list.
+     * @param {E} value - The value parameter is the value that you want to count the occurrences of in the linked list.
      * @returns The count of occurrences of the given value in the linked list.
      */
-    countOccurrences(value: T): number;
-    [Symbol.iterator](): Generator<T, void, unknown>;
+    countOccurrences(value: E): number;
+    [Symbol.iterator](): Generator<E, void, unknown>;
 }

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

@@ -8,7 +8,7 @@
 export class SinglyLinkedListNode {
     /**
      * The constructor function initializes an instance of a class with a given value and sets the next property to null.
-     * @param {T} val - The "val" parameter is of type T, which means it can be any data type. It represents the value that
+     * @param {E} val - The "val" parameter is of type E, which means it can be any data type. It represents the value that
      * will be stored in the node of a linked list.
      */
     constructor(val) {
@@ -55,7 +55,7 @@ export class SinglyLinkedList {
     /**
      * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
      * array.
-     * @param {T[]} data - The `data` parameter is an array of elements of type `T`.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
      * @returns The `fromArray` function returns a `SinglyLinkedList` object.
      */
     static fromArray(data) {
@@ -70,8 +70,8 @@ export class SinglyLinkedList {
     }
     /**
      * The `push` function adds a new node with the given data to the end of a singly linked list.
-     * @param {T} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
-     * any type (T) as specified in the generic type declaration of the class or function.
+     * @param {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * any type (E) as specified in the generic type declaration of the class or function.
      */
     push(data) {
         const newNode = new SinglyLinkedListNode(data);
@@ -125,7 +125,7 @@ export class SinglyLinkedList {
     }
     /**
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
-     * @param {T} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+     * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
      * linked list.
      */
     unshift(val) {
@@ -144,7 +144,7 @@ export class SinglyLinkedList {
      * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
      * retrieve from the list.
-     * @returns The method `getAt(index: number): T | null` returns the value at the specified index in the linked list, or
+     * @returns The method `getAt(index: number): E | null` returns the value at the specified index in the linked list, or
      * `null` if the index is out of bounds.
      */
     getAt(index) {
@@ -160,7 +160,7 @@ export class SinglyLinkedList {
      * The function `getNodeAt` returns the node at a given index in a singly linked list.
      * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
      * retrieve from the linked list. It indicates the zero-based index of the node we want to access.
-     * @returns The method `getNodeAt(index: number)` returns a `SinglyLinkedListNode<T>` object if the node at the
+     * @returns The method `getNodeAt(index: number)` returns a `SinglyLinkedListNode<E>` object if the node at the
      * specified index exists, or `null` if the index is out of bounds.
      */
     getNodeAt(index) {
@@ -192,8 +192,8 @@ export class SinglyLinkedList {
     }
     /**
      * The delete function removes a node with a specific value from a singly linked list.
-     * @param {T | SinglyLinkedListNode<T>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `T`
-     * or a `SinglyLinkedListNode<T>` object.
+     * @param {E | SinglyLinkedListNode<E>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `E`
+     * or a `SinglyLinkedListNode<E>` object.
      * @returns The `delete` method returns a boolean value. It returns `true` if the value or node is found and
      * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
      */
@@ -232,7 +232,7 @@ export class SinglyLinkedList {
      * The `insertAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
      * linked list. It is of type number.
-     * @param {T} val - The `val` parameter represents the value that you want to insert into the linked list at the
+     * @param {E} val - The `val` parameter represents the value that you want to insert into the linked list at the
      * specified index.
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
@@ -273,7 +273,7 @@ export class SinglyLinkedList {
     }
     /**
      * The `toArray` function converts a linked list into an array.
-     * @returns The `toArray()` method is returning an array of type `T[]`.
+     * @returns The `toArray()` method is returning an array of type `E[]`.
      */
     toArray() {
         const array = [];
@@ -304,7 +304,7 @@ export class SinglyLinkedList {
     }
     /**
      * The `find` function iterates through a linked list and returns the first element that satisfies a given condition.
-     * @param callback - A function that takes a value of type T as its parameter and returns a boolean value. This
+     * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a particular value in the linked list satisfies a certain condition.
      * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
      * the callback function. If no element satisfies the condition, it returns `null`.
@@ -321,7 +321,7 @@ export class SinglyLinkedList {
     }
     /**
      * The `indexOf` function returns the index of the first occurrence of a given value in a linked list.
-     * @param {T} value - The value parameter is the value that you want to find the index of in the linked list.
+     * @param {E} value - The value parameter is the value that you want to find the index of in the linked list.
      * @returns The method is returning the index of the first occurrence of the specified value in the linked list. If the
      * value is not found, it returns -1.
      */
@@ -340,8 +340,8 @@ export class SinglyLinkedList {
     /**
      * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
      * null.
-     * @param {T} value - The value parameter is the value that we want to search for in the linked list.
-     * @returns a `SinglyLinkedListNode<T>` if a node with the specified value is found in the linked list. If no node with
+     * @param {E} value - The value parameter is the value that we want to search for in the linked list.
+     * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
      * the specified value is found, the function returns `null`.
      */
     findNode(value) {
@@ -356,9 +356,9 @@ export class SinglyLinkedList {
     }
     /**
      * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
-     * @param {T | SinglyLinkedListNode<T>} existingValueOrNode - The existing value or node that you want to insert the
+     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
      * new value before. It can be either the value itself or a node containing the value in the linked list.
-     * @param {T} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
      * @returns The method `insertBefore` returns a boolean value. It returns `true` if the new value was successfully
      * inserted before the existing value, and `false` otherwise.
      */
@@ -391,9 +391,9 @@ export class SinglyLinkedList {
     }
     /**
      * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
-     * @param {T | SinglyLinkedListNode<T>} existingValueOrNode - The existing value or node in the linked list after which
+     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
      * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
-     * @param {T} newValue - The value that you want to insert into the linked list after the existing value or node.
+     * @param {E} newValue - The value that you want to insert into the linked list after the existing value or node.
      * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
      * existing value or node, and false if the existing value or node was not found in the linked list.
      */
@@ -419,7 +419,7 @@ export class SinglyLinkedList {
     }
     /**
      * The function counts the number of occurrences of a given value in a linked list.
-     * @param {T} value - The value parameter is the value that you want to count the occurrences of in the linked list.
+     * @param {E} value - The value parameter is the value that you want to count the occurrences of in the linked list.
      * @returns The count of occurrences of the given value in the linked list.
      */
     countOccurrences(value) {

package/lib/data-structures/matrix/matrix.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export declare class MatrixNTI2D<T = number> {
+export declare class MatrixNTI2D<V = any> {
     private readonly _matrix;
     /**
      * The constructor creates a matrix with the specified number of rows and columns, and initializes all elements to a
@@ -15,7 +15,7 @@ export declare class MatrixNTI2D<T = number> {
     constructor(options: {
         row: number;
         col: number;
-        initialVal?: T;
+        initialVal?: V;
     });
-    toArray(): Array<Array<T>>;
+    toArray(): Array<Array<V>>;
 }

package/lib/data-structures/matrix/matrix2d.d.ts

@@ -37,7 +37,7 @@ export declare class Matrix2D {
      * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
      * the first column of the matrix.
      */
-    get toVector(): Vector2D;
+    toVector(): Vector2D;
     /**
      * The function takes two 2D matrices as input and returns their sum as a new 2D matrix.
      * @param {Matrix2D} matrix1 - Matrix2D - The first matrix to be added.

package/lib/data-structures/matrix/matrix2d.js

@@ -59,7 +59,7 @@ export class Matrix2D {
      * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
      * the first column of the matrix.
      */
-    get toVector() {
+    toVector() {
         return new Vector2D(this._matrix[0][0], this._matrix[1][0]);
     }
     /**
@@ -134,7 +134,8 @@ export class Matrix2D {
      * @returns a Vector2D.
      */
     static multiplyByVector(matrix, vector) {
-        return Matrix2D.multiply(matrix, new Matrix2D(vector)).toVector;
+        const resultMatrix = Matrix2D.multiply(matrix, new Matrix2D(vector));
+        return resultMatrix.toVector();
     }
     /**
      * The function returns a 2D matrix that scales and flips a vector around the center of a given width and height.

package/lib/data-structures/priority-queue/max-priority-queue.d.ts

@@ -7,9 +7,9 @@
  */
 import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../../types';
-export declare class MaxPriorityQueue<T = number> extends PriorityQueue<T> {
+export declare class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
     constructor(options?: Omit<PriorityQueueOptions<number>, 'comparator'>);
-    constructor(options: PriorityQueueOptions<T>);
-    static heapify<T extends number>(options?: Omit<PriorityQueueOptions<T>, 'comparator'>): MaxPriorityQueue<T>;
-    static heapify<T>(options: PriorityQueueOptions<T>): MaxPriorityQueue<T>;
+    constructor(options: PriorityQueueOptions<E>);
+    static heapify<E extends number>(options?: Omit<PriorityQueueOptions<E>, 'comparator'>): MaxPriorityQueue<E>;
+    static heapify<E>(options: PriorityQueueOptions<E>): MaxPriorityQueue<E>;
 }

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

@@ -7,9 +7,9 @@
  */
 import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../../types';
-export declare class MinPriorityQueue<T = number> extends PriorityQueue<T> {
+export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
     constructor(options?: Omit<PriorityQueueOptions<number>, 'comparator'>);
-    constructor(options: PriorityQueueOptions<T>);
-    static heapify<T extends number>(options?: Omit<PriorityQueueOptions<T>, 'comparator'>): MinPriorityQueue<T>;
-    static heapify<T>(options: PriorityQueueOptions<T>): MinPriorityQueue<T>;
+    constructor(options: PriorityQueueOptions<E>);
+    static heapify<E extends number>(options?: Omit<PriorityQueueOptions<E>, 'comparator'>): MinPriorityQueue<E>;
+    static heapify<E>(options: PriorityQueueOptions<E>): MinPriorityQueue<E>;
 }

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

@@ -6,15 +6,15 @@
  * @license MIT License
  */
 import type { PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueueOptions } from '../../types';
-export declare class PriorityQueue<T = number> {
+export declare class PriorityQueue<E = any> {
     /**
      * The constructor initializes a priority queue with the given options, including an array of nodes and a comparator
      * function.
      * @param options - The `options` parameter is an object that contains the following properties:
      */
-    constructor(options: PriorityQueueOptions<T>);
-    protected _nodes: T[];
-    get nodes(): T[];
+    constructor(options: PriorityQueueOptions<E>);
+    protected _nodes: E[];
+    get nodes(): E[];
     get size(): number;
     /**
      * The `heapify` function creates a new PriorityQueue instance and fixes the heap property.
@@ -23,7 +23,7 @@ export declare class PriorityQueue<T = number> {
      * the priority queue, and "initialValues" which is an array of initial values to be added to the priority
      * @returns a new instance of the PriorityQueue class after performing the heapify operation on it.
      */
-    static heapify<T>(options: PriorityQueueOptions<T>): PriorityQueue<T>;
+    static heapify<E>(options: PriorityQueueOptions<E>): PriorityQueue<E>;
     /**
      * The function checks if a priority queue is valid by creating a new priority queue with a fix option and then calling
      * the isValid method.
@@ -31,41 +31,41 @@ export declare class PriorityQueue<T = number> {
      * following properties:
      * @returns the result of calling the `isValid()` method on a new instance of the `PriorityQueue` class.
      */
-    static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>): boolean;
+    static isPriorityQueueified<E>(options: Omit<PriorityQueueOptions<E>, 'isFix'>): boolean;
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
-    getNodes(): T[];
+    getNodes(): E[];
     /**
      * The "add" function adds a node to the heap and ensures that the heap property is maintained.
-     * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node
+     * @param {E} node - The parameter "node" is of type E, which means it can be any data type. It represents the node
      * that needs to be added to the heap.
      */
-    add(node: T): void;
+    add(node: E): void;
     /**
      * The "has" function checks if a given node is present in the list of nodes.
-     * @param {T} node - The parameter `node` is of type `T`, which means it can be any type. It represents the node that
+     * @param {E} node - The parameter `node` is of type `E`, which means it can be any type. It represents the node that
      * we want to check if it exists in the `nodes` array.
      * @returns a boolean value indicating whether the given node is included in the array of nodes.
      */
-    has(node: T): boolean;
+    has(node: E): boolean;
     /**
      * The `peek` function returns the first element of the `nodes` array if it exists, otherwise it returns `null`.
-     * @returns The `peek()` function is returning the first element (`T`) of the `nodes` array if the `size` is not zero.
+     * @returns The `peek()` function is returning the first element (`E`) of the `nodes` array if the `size` is not zero.
      * Otherwise, it returns `null`.
      */
-    peek(): T | null;
+    peek(): E | null;
     /**
      * The `poll` function removes and returns the top element from a heap data structure.
-     * @returns The `poll()` method returns a value of type `T` or `null`.
+     * @returns The `poll()` method returns a value of type `E` or `null`.
      */
-    poll(): T | null;
+    poll(): E | null;
     /**
      * The `leaf` function returns the last element in the `nodes` array or `null` if the array is empty.
-     * @returns The method `leaf()` is returning the last element (`T`) in the `nodes` array if it exists. If the array is
+     * @returns The method `leaf()` is returning the last element (`E`) in the `nodes` array if it exists. If the array is
      * empty or the last element is `null`, then it returns `null`.
      */
-    leaf(): T | null;
+    leaf(): E | null;
     /**
      * The function checks if the size of an object is equal to zero and returns a boolean value indicating whether the
      * object is empty or not.
@@ -79,16 +79,16 @@ export declare class PriorityQueue<T = number> {
     clear(): void;
     /**
      * The toArray function returns an array containing all the elements in the nodes property.
-     * @returns An array of type T, which is the elements of the nodes property.
+     * @returns An array of type E, which is the elements of the nodes property.
      */
-    toArray(): T[];
+    toArray(): E[];
     /**
      * The `clone` function returns a new instance of the `PriorityQueue` class with the same nodes and comparator as the
      * original instance.
      * @returns The `clone()` method is returning a new instance of the `PriorityQueue` class with the same `nodes` and
      * `comparator` properties as the original instance.
      */
-    clone(): PriorityQueue<T>;
+    clone(): PriorityQueue<E>;
     /**
      * The `isValid` function recursively checks if a binary tree satisfies a certain condition.
      * @returns The function `isValid()` returns a boolean value.
@@ -100,19 +100,19 @@ export declare class PriorityQueue<T = number> {
     /**
      * The function sorts the elements in a data structure and returns them in an array.
      * Plan to support sorting of duplicate elements.
-     * @returns The `sort()` method is returning an array of type `T[]`.
+     * @returns The `sort()` method is returning an array of type `E[]`.
      */
-    sort(): T[];
+    sort(): E[];
     /**
      * The DFS function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
      * based on the specified traversal order.
      * @param {PriorityQueueDFSOrderPattern} dfsMode - The dfsMode parameter is a string that specifies the order in which
      * the nodes should be visited during the Depth-First Search (DFS) traversal. It can have one of the following values:
-     * @returns an array of type `(T | null)[]`.
+     * @returns an array of type `(E | null)[]`.
      */
-    DFS(dfsMode: PriorityQueueDFSOrderPattern): (T | null)[];
-    protected _setNodes(value: T[]): void;
-    protected readonly _comparator: PriorityQueueComparator<T>;
+    DFS(dfsMode: PriorityQueueDFSOrderPattern): (E | null)[];
+    protected _setNodes(value: E[]): void;
+    protected readonly _comparator: PriorityQueueComparator<E>;
     /**
      * The function compares two numbers using a custom comparator function.
      * @param {number} a - The parameter "a" is a number that represents the index of a node in an array.

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

@@ -54,7 +54,7 @@ export class PriorityQueue {
     }
     /**
      * The "add" function adds a node to the heap and ensures that the heap property is maintained.
-     * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node
+     * @param {E} node - The parameter "node" is of type E, which means it can be any data type. It represents the node
      * that needs to be added to the heap.
      */
     add(node) {
@@ -63,7 +63,7 @@ export class PriorityQueue {
     }
     /**
      * The "has" function checks if a given node is present in the list of nodes.
-     * @param {T} node - The parameter `node` is of type `T`, which means it can be any type. It represents the node that
+     * @param {E} node - The parameter `node` is of type `E`, which means it can be any type. It represents the node that
      * we want to check if it exists in the `nodes` array.
      * @returns a boolean value indicating whether the given node is included in the array of nodes.
      */
@@ -72,7 +72,7 @@ export class PriorityQueue {
     }
     /**
      * The `peek` function returns the first element of the `nodes` array if it exists, otherwise it returns `null`.
-     * @returns The `peek()` function is returning the first element (`T`) of the `nodes` array if the `size` is not zero.
+     * @returns The `peek()` function is returning the first element (`E`) of the `nodes` array if the `size` is not zero.
      * Otherwise, it returns `null`.
      */
     peek() {
@@ -80,7 +80,7 @@ export class PriorityQueue {
     }
     /**
      * The `poll` function removes and returns the top element from a heap data structure.
-     * @returns The `poll()` method returns a value of type `T` or `null`.
+     * @returns The `poll()` method returns a value of type `E` or `null`.
      */
     poll() {
         var _a, _b;
@@ -97,7 +97,7 @@ export class PriorityQueue {
     }
     /**
      * The `leaf` function returns the last element in the `nodes` array or `null` if the array is empty.
-     * @returns The method `leaf()` is returning the last element (`T`) in the `nodes` array if it exists. If the array is
+     * @returns The method `leaf()` is returning the last element (`E`) in the `nodes` array if it exists. If the array is
      * empty or the last element is `null`, then it returns `null`.
      */
     leaf() {
@@ -121,7 +121,7 @@ export class PriorityQueue {
     }
     /**
      * The toArray function returns an array containing all the elements in the nodes property.
-     * @returns An array of type T, which is the elements of the nodes property.
+     * @returns An array of type E, which is the elements of the nodes property.
      */
     toArray() {
         return [...this.nodes];
@@ -162,7 +162,7 @@ export class PriorityQueue {
     /**
      * The function sorts the elements in a data structure and returns them in an array.
      * Plan to support sorting of duplicate elements.
-     * @returns The `sort()` method is returning an array of type `T[]`.
+     * @returns The `sort()` method is returning an array of type `E[]`.
      */
     sort() {
         const visitedNode = [];
@@ -178,7 +178,7 @@ export class PriorityQueue {
      * based on the specified traversal order.
      * @param {PriorityQueueDFSOrderPattern} dfsMode - The dfsMode parameter is a string that specifies the order in which
      * the nodes should be visited during the Depth-First Search (DFS) traversal. It can have one of the following values:
-     * @returns an array of type `(T | null)[]`.
+     * @returns an array of type `(E | null)[]`.
      */
     DFS(dfsMode) {
         const visitedNode = [];