min-heap-typed 1.39.0 → 1.39.2

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

@@ -124,11 +124,11 @@ class DoublyLinkedList {
         return removedNode.val;
     }
     /**
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+     * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
      * list is empty, it returns null.
      */
-    pollLast() {
+    popLast() {
         return this.pop();
     }
     /**
@@ -152,11 +152,11 @@ class DoublyLinkedList {
         return removedNode.val;
     }
     /**
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
      * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
      * list.
      */
-    pollFirst() {
+    popFirst() {
         return this.shift();
     }
     /**
@@ -186,18 +186,18 @@ class DoublyLinkedList {
         this.unshift(val);
     }
     /**
-     * The `peekFirst` function returns the first node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
+     * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
      */
-    peekFirst() {
+    getFirst() {
         var _a;
         return (_a = this.head) === null || _a === void 0 ? void 0 : _a.val;
     }
     /**
-     * The `peekLast` function returns the last node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
+     * The `getLast` function returns the last node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
      */
-    peekLast() {
+    getLast() {
         var _a;
         return (_a = this.tail) === null || _a === void 0 ? void 0 : _a.val;
     }
@@ -241,7 +241,7 @@ class DoublyLinkedList {
      * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
      * is found in the linked list. If no such node is found, it returns `null`.
      */
-    findNode(val) {
+    getNode(val) {
         let current = this.head;
         while (current) {
             if (current.val === val) {
@@ -281,6 +281,40 @@ class DoublyLinkedList {
         this._length++;
         return true;
     }
+    /**
+     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
+     * list.
+     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion fails.
+     */
+    insertBefore(existingValueOrNode, newValue) {
+        let existingNode;
+        if (existingValueOrNode instanceof DoublyLinkedListNode) {
+            existingNode = existingValueOrNode;
+        }
+        else {
+            existingNode = this.getNode(existingValueOrNode);
+        }
+        if (existingNode) {
+            const newNode = new DoublyLinkedListNode(newValue);
+            newNode.prev = existingNode.prev;
+            if (existingNode.prev) {
+                existingNode.prev.next = newNode;
+            }
+            newNode.next = existingNode;
+            existingNode.prev = newNode;
+            if (existingNode === this.head) {
+                this.head = newNode;
+            }
+            this._length++;
+            return true;
+        }
+        return false;
+    }
     /**
      * 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
@@ -316,7 +350,7 @@ class DoublyLinkedList {
             node = valOrNode;
         }
         else {
-            node = this.findNode(valOrNode);
+            node = this.getNode(valOrNode);
         }
         if (node) {
             if (node === this.head) {
@@ -401,14 +435,14 @@ class DoublyLinkedList {
         return -1;
     }
     /**
-     * The `findLast` function iterates through a linked list from the last node to the first node and returns the last
+     * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
      * value that satisfies the given callback function, or null if no value satisfies the callback.
      * @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 given value satisfies a certain condition.
-     * @returns The method `findLast` returns the last value in the linked list that satisfies the condition specified by
+     * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
      * the callback function. If no value satisfies the condition, it returns `null`.
      */
-    findLast(callback) {
+    findBackward(callback) {
         let current = this.tail;
         while (current) {
             if (callback(current.val)) {
@@ -419,10 +453,10 @@ class DoublyLinkedList {
         return null;
     }
     /**
-     * The `toArrayReverse` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayReverse()` function returns an array of type `E[]`.
+     * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toArrayBackward()` function returns an array of type `E[]`.
      */
-    toArrayReverse() {
+    toArrayBackward() {
         const array = [];
         let current = this.tail;
         while (current) {
@@ -527,7 +561,7 @@ class DoublyLinkedList {
             existingNode = existingValueOrNode;
         }
         else {
-            existingNode = this.findNode(existingValueOrNode);
+            existingNode = this.getNode(existingValueOrNode);
         }
         if (existingNode) {
             const newNode = new DoublyLinkedListNode(newValue);
@@ -546,38 +580,14 @@ class DoublyLinkedList {
         return false;
     }
     /**
-     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
-     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
-     * itself.
-     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
-     * list.
-     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
-     * insertion fails.
+     * The function returns an iterator that iterates over the values of a linked list.
      */
-    insertBefore(existingValueOrNode, newValue) {
-        let existingNode;
-        if (existingValueOrNode instanceof DoublyLinkedListNode) {
-            existingNode = existingValueOrNode;
-        }
-        else {
-            existingNode = this.findNode(existingValueOrNode);
-        }
-        if (existingNode) {
-            const newNode = new DoublyLinkedListNode(newValue);
-            newNode.prev = existingNode.prev;
-            if (existingNode.prev) {
-                existingNode.prev.next = newNode;
-            }
-            newNode.next = existingNode;
-            existingNode.prev = newNode;
-            if (existingNode === this.head) {
-                this.head = newNode;
-            }
-            this._length++;
-            return true;
+    *[Symbol.iterator]() {
+        let current = this.head;
+        while (current) {
+            yield current.val;
+            current = current.next;
         }
-        return false;
     }
 }
 exports.DoublyLinkedList = DoublyLinkedList;

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

@@ -39,13 +39,18 @@ export declare class SinglyLinkedList<E = any> {
      * @returns The `fromArray` function returns a `SinglyLinkedList` object.
      */
     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 {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" 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: E): void;
+    push(val: E): void;
+    /**
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" 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.
+     */
+    addLast(val: 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.
@@ -53,17 +58,35 @@ export declare class SinglyLinkedList<E = any> {
      * the linked list is empty, it returns `null`.
      */
     pop(): E | undefined;
+    /**
+     * The `popLast()` 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`.
+     */
+    popLast(): 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(): E | undefined;
+    /**
+     * The `popFirst()` 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.
+     */
+    popFirst(): E | undefined;
     /**
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
      * @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: E): void;
+    /**
+     * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
+     * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+     * linked list.
+     */
+    addFirst(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
@@ -148,7 +171,7 @@ export declare class SinglyLinkedList<E = any> {
      * @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: E): SinglyLinkedListNode<E> | null;
+    getNode(value: E): SinglyLinkedListNode<E> | null;
     /**
      * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
@@ -158,13 +181,58 @@ export declare class SinglyLinkedList<E = any> {
      * inserted before the existing value, and `false` otherwise.
      */
     insertBefore(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
-    insertAfter(existingValueOrNode: E, newValue: E): boolean;
-    insertAfter(existingValueOrNode: SinglyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
+     * @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 {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.
+     */
+    insertAfter(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
     /**
      * The function counts the number of occurrences of a given value in a 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: E): number;
+    /**
+     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+     * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
+     * represents the value of the current node in the linked list, and the index argument represents the index of the
+     * current node in the linked list.
+     */
+    forEach(callback: (val: E, index: number) => void): void;
+    /**
+     * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
+     * SinglyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+     * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
+     * SinglyLinkedList).
+     * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+     */
+    map<U>(callback: (val: E) => U): SinglyLinkedList<U>;
+    /**
+     * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the SinglyLinkedList class.
+     */
+    filter(callback: (val: E) => boolean): SinglyLinkedList<E>;
+    /**
+     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+     * single value.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
+     * used to perform a specific operation on each element of the linked list.
+     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * point for the reduction operation.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+     * elements in the linked list.
+     */
+    reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U;
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
     [Symbol.iterator](): Generator<E, void, unknown>;
 }

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

@@ -69,16 +69,13 @@ class SinglyLinkedList {
         }
         return singlyLinkedList;
     }
-    getLength() {
-        return this._length;
-    }
     /**
-     * The `push` function adds a new node with the given data to the end of a singly linked list.
-     * @param {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" 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);
+    push(val) {
+        const newNode = new SinglyLinkedListNode(val);
         if (!this.head) {
             this.head = newNode;
             this.tail = newNode;
@@ -89,6 +86,14 @@ class SinglyLinkedList {
         }
         this._length++;
     }
+    /**
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" 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.
+     */
+    addLast(val) {
+        this.push(val);
+    }
     /**
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
@@ -115,6 +120,15 @@ class SinglyLinkedList {
         this._length--;
         return val;
     }
+    /**
+     * The `popLast()` 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`.
+     */
+    popLast() {
+        return this.pop();
+    }
     /**
      * 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.
@@ -127,6 +141,13 @@ class SinglyLinkedList {
         this._length--;
         return removedNode.val;
     }
+    /**
+     * The `popFirst()` 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.
+     */
+    popFirst() {
+        return this.shift();
+    }
     /**
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
      * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
@@ -144,6 +165,14 @@ class SinglyLinkedList {
         }
         this._length++;
     }
+    /**
+     * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
+     * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+     * linked list.
+     */
+    addFirst(val) {
+        this.unshift(val);
+    }
     /**
      * 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
@@ -350,7 +379,7 @@ class SinglyLinkedList {
      * @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) {
+    getNode(value) {
         let current = this.head;
         while (current) {
             if (current.val === value) {
@@ -409,7 +438,7 @@ class SinglyLinkedList {
             existingNode = existingValueOrNode;
         }
         else {
-            existingNode = this.findNode(existingValueOrNode);
+            existingNode = this.getNode(existingValueOrNode);
         }
         if (existingNode) {
             const newNode = new SinglyLinkedListNode(newValue);
@@ -439,6 +468,78 @@ class SinglyLinkedList {
         }
         return count;
     }
+    /**
+     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+     * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
+     * represents the value of the current node in the linked list, and the index argument represents the index of the
+     * current node in the linked list.
+     */
+    forEach(callback) {
+        let current = this.head;
+        let index = 0;
+        while (current) {
+            callback(current.val, index);
+            current = current.next;
+            index++;
+        }
+    }
+    /**
+     * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
+     * SinglyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+     * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
+     * SinglyLinkedList).
+     * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+     */
+    map(callback) {
+        const mappedList = new SinglyLinkedList();
+        let current = this.head;
+        while (current) {
+            mappedList.push(callback(current.val));
+            current = current.next;
+        }
+        return mappedList;
+    }
+    /**
+     * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the SinglyLinkedList class.
+     */
+    filter(callback) {
+        const filteredList = new SinglyLinkedList();
+        let current = this.head;
+        while (current) {
+            if (callback(current.val)) {
+                filteredList.push(current.val);
+            }
+            current = current.next;
+        }
+        return filteredList;
+    }
+    /**
+     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+     * single value.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
+     * used to perform a specific operation on each element of the linked list.
+     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * point for the reduction operation.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+     * elements in the linked list.
+     */
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let current = this.head;
+        while (current) {
+            accumulator = callback(accumulator, current.val);
+            current = current.next;
+        }
+        return accumulator;
+    }
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
     *[Symbol.iterator]() {
         let current = this.head;
         while (current) {

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import Vector2D from './vector2d';
+import { Vector2D } from './vector2d';
 export declare class Matrix2D {
     private readonly _matrix;
     /**
@@ -105,4 +105,3 @@ export declare class Matrix2D {
      */
     toVector(): Vector2D;
 }
-export default Matrix2D;

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

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Matrix2D = void 0;
 /**
@@ -11,7 +8,7 @@ exports.Matrix2D = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-const vector2d_1 = __importDefault(require("./vector2d"));
+const vector2d_1 = require("./vector2d");
 class Matrix2D {
     /**
      * The constructor function initializes a Matrix2D object with either a default identity matrix, or a provided matrix
@@ -23,7 +20,7 @@ class Matrix2D {
         if (typeof value === 'undefined') {
             this._matrix = Matrix2D.identity;
         }
-        else if (value instanceof vector2d_1.default) {
+        else if (value instanceof vector2d_1.Vector2D) {
             this._matrix = Matrix2D.identity;
             this._matrix[0][0] = value.x;
             this._matrix[1][0] = value.y;
@@ -196,8 +193,7 @@ class Matrix2D {
      * the first column of the matrix.
      */
     toVector() {
-        return new vector2d_1.default(this._matrix[0][0], this._matrix[1][0]);
+        return new vector2d_1.Vector2D(this._matrix[0][0], this._matrix[1][0]);
     }
 }
 exports.Matrix2D = Matrix2D;
-exports.default = Matrix2D;

package/dist/data-structures/matrix/vector2d.d.ts

@@ -198,4 +198,3 @@ export declare class Vector2D {
      */
     zero(): void;
 }
-export default Vector2D;

package/dist/data-structures/matrix/vector2d.js

@@ -288,4 +288,3 @@ class Vector2D {
     }
 }
 exports.Vector2D = Vector2D;
-exports.default = Vector2D;

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

@@ -37,25 +37,25 @@ export declare class ObjectDeque<E = number> {
      */
     addLast(value: E): void;
     /**
-     * The function `pollFirst()` removes and returns the first element in a data structure.
+     * The function `popFirst()` removes and returns the first element in a data structure.
      * @returns The value of the first element in the data structure.
      */
-    pollFirst(): E | undefined;
+    popFirst(): E | undefined;
     /**
-     * The `peekFirst` function returns the first element in an array-like data structure if it exists.
+     * The `getFirst` function returns the first element in an array-like data structure if it exists.
      * @returns The element at the first position of the `_nodes` array.
      */
-    peekFirst(): E | undefined;
+    getFirst(): E | undefined;
     /**
-     * The `pollLast()` function removes and returns the last element in a data structure.
+     * The `popLast()` function removes and returns the last element in a data structure.
      * @returns The value that was removed from the data structure.
      */
-    pollLast(): E | undefined;
+    popLast(): E | undefined;
     /**
-     * The `peekLast()` function returns the last element in an array-like data structure.
+     * The `getLast()` function returns the last element in an array-like data structure.
      * @returns The last element in the array "_nodes" is being returned.
      */
-    peekLast(): E | undefined;
+    getLast(): E | undefined;
     /**
      * The get function returns the element at the specified index in an array-like data structure.
      * @param {number} index - The index parameter is a number that represents the position of the element you want to
@@ -87,16 +87,16 @@ export declare class ArrayDeque<E> {
      */
     addLast(value: E): number;
     /**
-     * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
-     * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
+     * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    pollLast(): E | null;
+    popLast(): E | null;
     /**
-     * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
-     * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
+     * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+     * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
      * empty.
      */
-    pollFirst(): E | null;
+    popFirst(): E | null;
     /**
      * O(n) time complexity of adding at the beginning and the end
      */
@@ -108,16 +108,16 @@ export declare class ArrayDeque<E> {
      */
     addFirst(value: E): number;
     /**
-     * The `peekFirst` function returns the first element of an array or null if the array is empty.
-     * @returns The function `peekFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
+     * The `getFirst` function returns the first element of an array or null if the array is empty.
+     * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
      * empty, it will return `null`.
      */
-    peekFirst(): E | null;
+    getFirst(): E | null;
     /**
-     * The `peekLast` function returns the last element of an array or null if the array is empty.
-     * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     * The `getLast` function returns the last element of an array or null if the array is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    peekLast(): E | null;
+    getLast(): E | null;
     /**
      * O(1) time complexity of obtaining the value
      */