data-structure-typed 1.15.1 → 1.16.1

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

@@ -1,6 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heap = void 0;
+exports.Heap = exports.HeapItem = void 0;
+var HeapItem = /** @class */ (function () {
+    function HeapItem(priority, val) {
+        if (priority === void 0) { priority = NaN; }
+        if (val === void 0) { val = null; }
+        this._val = val;
+        this._priority = priority;
+    }
+    Object.defineProperty(HeapItem.prototype, "priority", {
+        get: function () {
+            return this._priority;
+        },
+        set: function (value) {
+            this._priority = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HeapItem.prototype, "val", {
+        get: function () {
+            return this._val;
+        },
+        set: function (value) {
+            this._val = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return HeapItem;
+}());
+exports.HeapItem = HeapItem;
 var Heap = /** @class */ (function () {
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
@@ -29,12 +59,6 @@ var Heap = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * 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.
-     */
-    Heap.prototype.getPq = function () {
-        return this._pq;
-    };
     Object.defineProperty(Heap.prototype, "priorityCb", {
         get: function () {
             return this._priorityCb;
@@ -45,12 +69,6 @@ var Heap = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * 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.
-     */
-    Heap.prototype.getPriorityCb = function () {
-        return this._priorityCb;
-    };
     Object.defineProperty(Heap.prototype, "size", {
         /**
          * The function returns the size of a priority queue.
@@ -62,6 +80,18 @@ var Heap = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * 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.
+     */
+    Heap.prototype.getPq = function () {
+        return this._pq;
+    };
+    /**
+     * 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.
+     */
+    Heap.prototype.getPriorityCb = function () {
+        return this._priorityCb;
+    };
     /**
      * 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.
      */
@@ -77,31 +107,31 @@ var Heap = /** @class */ (function () {
     };
     /**
      * The `peek` function returns the top item in the priority queue without removing it.
-     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an val with the highest priority in the queue
      */
     Heap.prototype.peek = function () {
         return this._pq.peek();
     };
     /**
      * The `peekLast` function returns the last item in the heap.
-     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
     Heap.prototype.peekLast = function () {
         return this._pq.leaf();
     };
     /**
-     * The `add` function adds an element to a priority queue with an optional priority value.
-     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
+     * The `add` function adds an val to a priority queue with an optional priority value.
+     * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * element being added to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
-     * the value of `element`. If the `element` parameter is not a number, then the
+     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
+     * the value of `val`. If the `val` parameter is not a number, then the
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    Heap.prototype.add = function (element, priority) {
-        if (typeof element === 'number') {
-            priority = element;
+    Heap.prototype.add = function (val, priority) {
+        if (typeof val === 'number') {
+            priority = val;
         }
         else {
             if (priority === undefined) {
@@ -111,16 +141,16 @@ var Heap = /** @class */ (function () {
         if (priority && Number.isNaN(+priority)) {
             throw new Error('.add expects a numeric priority');
         }
-        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(element))) {
+        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(val))) {
             throw new Error('.add expects a numeric priority '
                 + 'or a constructor callback that returns a number');
         }
-        var _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.add({ priority: _priority, element: element });
+        var _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(val);
+        this._pq.add(new HeapItem(_priority, val));
         return this;
     };
     /**
-     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
      * @returns either a HeapItem<T> object or null.
      */
     Heap.prototype.poll = function () {
@@ -130,9 +160,24 @@ var Heap = /** @class */ (function () {
         }
         return top;
     };
+    /**
+     * The function checks if a given node or value exists in the priority queue.
+     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
+     * @returns a boolean value.
+     */
+    Heap.prototype.has = function (node) {
+        if (node instanceof (HeapItem)) {
+            return this.getPq().getNodes().includes(node);
+        }
+        else {
+            return this.getPq().getNodes().findIndex(function (item) {
+                return item.val === node;
+            }) !== -1;
+        }
+    };
     /**
      * The `toArray` function returns an array of `HeapItem<T>` objects.
-     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
     Heap.prototype.toArray = function () {
         return this._pq.toArray();

package/dist/data-structures/heap/max-heap.d.ts

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { Heap } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
+import type { HeapOptions } from '../types';
 /**
  * @class MaxHeap
  * @extends Heap
  */
-export declare class MaxHeap<T> extends Heap<T> {
+export declare class MaxHeap<T = number> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
     /**
      * The constructor initializes a PriorityQueue with a custom comparator function.

package/dist/data-structures/heap/min-heap.d.ts

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { Heap } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
+import type { HeapOptions } from '../types';
 /**
  * @class MinHeap
  * @extends Heap
  */
-export declare class MinHeap<T> extends Heap<T> {
+export declare class MinHeap<T = number> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
     /**
      * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem

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

@@ -4,6 +4,7 @@ export * from './stack';
 export * from './queue';
 export * from './graph';
 export * from './binary-tree';
+export * from './tree';
 export * from './heap';
 export * from './priority-queue';
 export * from './matrix';

package/dist/data-structures/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./stack"), exports);
 __exportStar(require("./queue"), exports);
 __exportStar(require("./graph"), exports);
 __exportStar(require("./binary-tree"), exports);
+__exportStar(require("./tree"), exports);
 __exportStar(require("./heap"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./matrix"), exports);

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

@@ -1,4 +1,5 @@
 export declare class DoublyLinkedListNode<T> {
+    constructor(nodeValue: T);
     protected _val: T;
     get val(): T;
     set val(v: T);
@@ -8,31 +9,30 @@ export declare class DoublyLinkedListNode<T> {
     protected _prev: DoublyLinkedListNode<T> | null;
     get prev(): DoublyLinkedListNode<T> | null;
     set prev(v: DoublyLinkedListNode<T> | null);
-    constructor(nodeValue: T);
 }
 export declare class DoublyLinkedList<T> {
+    constructor();
     protected _first: DoublyLinkedListNode<T> | null;
     get first(): DoublyLinkedListNode<T> | null;
+    protected set first(v: DoublyLinkedListNode<T> | null);
+    protected _last: DoublyLinkedListNode<T> | null;
+    get last(): DoublyLinkedListNode<T> | null;
+    protected set last(v: DoublyLinkedListNode<T> | null);
+    protected _size: number;
+    get size(): number;
+    protected set size(v: number);
     /**
      * 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.
      */
     getFirst(): DoublyLinkedListNode<T> | null;
-    protected set first(v: DoublyLinkedListNode<T> | null);
-    protected _last: DoublyLinkedListNode<T> | null;
-    get last(): DoublyLinkedListNode<T> | null;
     /**
      * 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.
      */
     getLast(): DoublyLinkedListNode<T> | null;
-    protected set last(v: DoublyLinkedListNode<T> | null);
-    protected _size: number;
-    get size(): number;
     /**
      * 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.
      */
     getSize(): number;
-    protected set size(v: number);
-    constructor();
     /**
      * The function adds a new node with a given value to the beginning of a doubly linked list.
      * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of

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

@@ -56,12 +56,6 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * 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.
-     */
-    DoublyLinkedList.prototype.getFirst = function () {
-        return this._first;
-    };
     Object.defineProperty(DoublyLinkedList.prototype, "last", {
         get: function () {
             return this._last;
@@ -72,12 +66,6 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * 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.
-     */
-    DoublyLinkedList.prototype.getLast = function () {
-        return this._last;
-    };
     Object.defineProperty(DoublyLinkedList.prototype, "size", {
         get: function () {
             return this._size;
@@ -88,6 +76,18 @@ var DoublyLinkedList = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * 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.
+     */
+    DoublyLinkedList.prototype.getFirst = function () {
+        return this._first;
+    };
+    /**
+     * 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.
+     */
+    DoublyLinkedList.prototype.getLast = function () {
+        return this._last;
+    };
     /**
      * 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.
      */

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

@@ -6,6 +6,7 @@
  * @license MIT License
  */
 export declare class SinglyLinkedListNode<NodeVal = any> {
+    constructor(val: NodeVal, prev?: SinglyLinkedListNode<NodeVal> | null, next?: SinglyLinkedListNode<NodeVal> | null, list?: SinglyLinkedList<NodeVal> | null);
     protected _val: NodeVal;
     get val(): NodeVal;
     set val(value: NodeVal);
@@ -18,7 +19,6 @@ export declare class SinglyLinkedListNode<NodeVal = any> {
     protected _list: SinglyLinkedList<NodeVal> | null;
     get list(): SinglyLinkedList<NodeVal> | null;
     set list(value: SinglyLinkedList<NodeVal> | null);
-    constructor(val: NodeVal, prev?: SinglyLinkedListNode<NodeVal> | null, next?: SinglyLinkedListNode<NodeVal> | null, list?: SinglyLinkedList<NodeVal> | null);
     get index(): number | undefined;
     /**
      * The `insertBefore` function inserts a new node with the given value before the current node in a singly linked list.
@@ -40,6 +40,12 @@ export declare class SinglyLinkedListNode<NodeVal = any> {
     remove(): SinglyLinkedListNode<NodeVal>;
 }
 export declare class SinglyLinkedList<NodeVal = any> {
+    /**
+     * The constructor initializes a linked list with the given arguments as nodes.
+     * @param {NodeVal[]} args - args is a rest parameter that allows the constructor to accept an arbitrary number of
+     * arguments of type NodeVal.
+     */
+    constructor(...args: NodeVal[]);
     protected _head: SinglyLinkedListNode<NodeVal> | null;
     get head(): SinglyLinkedListNode<NodeVal> | null;
     set head(value: SinglyLinkedListNode<NodeVal> | null);
@@ -49,12 +55,6 @@ export declare class SinglyLinkedList<NodeVal = any> {
     protected _size: number;
     get size(): number;
     set size(value: number);
-    /**
-     * The constructor initializes a linked list with the given arguments as nodes.
-     * @param {NodeVal[]} args - args is a rest parameter that allows the constructor to accept an arbitrary number of
-     * arguments of type NodeVal.
-     */
-    constructor(...args: NodeVal[]);
     /**
      * The `from` function in TypeScript creates a new SinglyLinkedList instance from an iterable object.
      * @param iterable - The `iterable` parameter is an object that can be iterated over, such as an array or a string. It

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

@@ -8,9 +8,8 @@
 import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../types';
 export declare class MaxPriorityQueue<T = number> extends PriorityQueue<T> {
-    /**
-     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
-     * @param [options] - An optional object that contains the following properties:
-     */
-    constructor(options?: PriorityQueueOptions<T>);
+    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>;
 }

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

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxPriorityQueue = void 0;
 /**
@@ -27,17 +38,30 @@ var priority_queue_1 = require("./priority-queue");
 var MaxPriorityQueue = /** @class */ (function (_super) {
     __extends(MaxPriorityQueue, _super);
     /**
-     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
-     * @param [options] - An optional object that contains the following properties:
+     * The constructor initializes a priority queue with an optional comparator function.
+     * @param [options] - The `options` parameter is an optional object that can contain various properties to configure
+     * the priority queue.
      */
     function MaxPriorityQueue(options) {
-        return _super.call(this, {
-            nodes: options === null || options === void 0 ? void 0 : options.nodes, comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+        return _super.call(this, __assign(__assign({}, options), { comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
                 var aKey = a, bKey = b;
                 return bKey - aKey;
-            }
-        }) || this;
+            } })) || this;
     }
+    /**
+     * The function `heapify` creates a max priority queue from the given options and returns it.
+     * @param options - The `options` parameter is an object that contains configuration options for creating a priority
+     * queue. It can have the following properties:
+     * @returns a MaxPriorityQueue object.
+     */
+    MaxPriorityQueue.heapify = function (options) {
+        var maxPQ = new MaxPriorityQueue(__assign(__assign({}, options), { comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+                var aKey = a, bKey = b;
+                return bKey - aKey;
+            } }));
+        maxPQ._fix();
+        return maxPQ;
+    };
     return MaxPriorityQueue;
 }(priority_queue_1.PriorityQueue));
 exports.MaxPriorityQueue = MaxPriorityQueue;

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

@@ -8,9 +8,8 @@
 import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../types';
 export declare class MinPriorityQueue<T = number> extends PriorityQueue<T> {
-    /**
-     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
-     * @param [options] - An optional object that contains the following properties:
-     */
-    constructor(options?: PriorityQueueOptions<T>);
+    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>;
 }

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

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinPriorityQueue = void 0;
 /**
@@ -27,17 +38,31 @@ var priority_queue_1 = require("./priority-queue");
 var MinPriorityQueue = /** @class */ (function (_super) {
     __extends(MinPriorityQueue, _super);
     /**
-     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
-     * @param [options] - An optional object that contains the following properties:
+     * The constructor initializes a priority queue with an optional comparator function.
+     * @param [options] - The `options` parameter is an optional object that can contain various configuration options for
+     * the `PriorityQueue` constructor.
      */
     function MinPriorityQueue(options) {
-        return _super.call(this, {
-            nodes: options === null || options === void 0 ? void 0 : options.nodes, comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+        return _super.call(this, __assign(__assign({}, options), { comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
                 var aKey = a, bKey = b;
                 return aKey - bKey;
-            }
-        }) || this;
+            } })) || this;
     }
+    /**
+     * The function `heapify` creates a new MinPriorityQueue instance and sets the comparator function based on the options
+     * provided, and then fixes the heap structure of the queue.
+     * @param options - The `options` parameter is an object that contains configuration options for creating a priority
+     * queue. It can have the following properties:
+     * @returns a MinPriorityQueue object.
+     */
+    MinPriorityQueue.heapify = function (options) {
+        var minPQ = new MinPriorityQueue(__assign(__assign({}, options), { comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+                var aKey = a, bKey = b;
+                return aKey - bKey;
+            } }));
+        minPQ._fix();
+        return minPQ;
+    };
     return MinPriorityQueue;
 }(priority_queue_1.PriorityQueue));
 exports.MinPriorityQueue = MinPriorityQueue;

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

@@ -7,19 +7,15 @@
  */
 import type { PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueueOptions } from '../types';
 export declare class PriorityQueue<T = number> {
-    protected _nodes: T[];
-    get nodes(): T[];
-    /**
-     * 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[];
-    protected set nodes(value: T[]);
     /**
      * 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[];
+    protected set nodes(value: T[]);
     get size(): number;
     /**
      * The `heapify` function creates a new PriorityQueue instance and fixes the heap property.
@@ -37,12 +33,23 @@ export declare class PriorityQueue<T = number> {
      * @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;
+    /**
+     * 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[];
     /**
      * 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
      * that needs to be added to the heap.
      */
     add(node: T): 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
+     * 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;
     /**
      * 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.
@@ -89,8 +96,12 @@ export declare class PriorityQueue<T = number> {
      */
     isValid(): boolean;
     /**
-     * The function sorts the elements in a data structure and returns them in ascending order.
-     * @returns The `sort()` function is returning an array of type `T[]`.
+     * Plan to support sorting of duplicate elements.
+     */
+    /**
+     * 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[]`.
      */
     sort(): T[];
     /**