data-structure-typed 1.19.7 → 1.19.8

package/dist/data-structures/binary-tree/avl-tree.js

@@ -10,6 +10,9 @@ exports.AVLTree = exports.AVLTreeNode = void 0;
  */
 const bst_1 = require("./bst");
 class AVLTreeNode extends bst_1.BSTNode {
+    constructor(id, val) {
+        super(id, val);
+    }
 }
 exports.AVLTreeNode = AVLTreeNode;
 class AVLTree extends bst_1.BST {
@@ -41,6 +44,7 @@ class AVLTree extends bst_1.BST {
      * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
      */
     add(id, val) {
+        // TODO support node as a param
         const inserted = super.add(id, val);
         if (inserted)
             this.balancePath(inserted);

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -7,8 +7,9 @@
  */
 import type { BinaryTreeNodeId, BinaryTreeNodeNested, BinaryTreeOptions } from '../types';
 import { AbstractBinaryTree, AbstractBinaryTreeNode } from './abstract-binary-tree';
-import { IBinaryTree, IBinaryTreeNode } from '../interfaces/binary-tree';
+import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
 export declare class BinaryTreeNode<T = any, NEIGHBOR extends BinaryTreeNode<T, NEIGHBOR> = BinaryTreeNodeNested<T>> extends AbstractBinaryTreeNode<T, NEIGHBOR> implements IBinaryTreeNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: T);
 }
 export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> extends AbstractBinaryTree<N> implements IBinaryTree<N> {
     /**

package/dist/data-structures/binary-tree/binary-tree.js

@@ -10,6 +10,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryTree = exports.BinaryTreeNode = void 0;
 const abstract_binary_tree_1 = require("./abstract-binary-tree");
 class BinaryTreeNode extends abstract_binary_tree_1.AbstractBinaryTreeNode {
+    constructor(id, val) {
+        super(id, val);
+    }
 }
 exports.BinaryTreeNode = BinaryTreeNode;
 class BinaryTree extends abstract_binary_tree_1.AbstractBinaryTree {

package/dist/data-structures/binary-tree/bst.d.ts

@@ -10,6 +10,7 @@ import { CP } from '../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBST, IBSTNode } from '../interfaces';
 export declare class BSTNode<T = any, NEIGHBOR extends BSTNode<T, NEIGHBOR> = BSTNodeNested<T>> extends BinaryTreeNode<T, NEIGHBOR> implements IBSTNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: T);
 }
 export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
     /**

package/dist/data-structures/binary-tree/bst.js

@@ -4,6 +4,9 @@ exports.BST = exports.BSTNode = void 0;
 const types_1 = require("../types");
 const binary_tree_1 = require("./binary-tree");
 class BSTNode extends binary_tree_1.BinaryTreeNode {
+    constructor(id, val) {
+        super(id, val);
+    }
 }
 exports.BSTNode = BSTNode;
 class BST extends binary_tree_1.BinaryTree {
@@ -42,6 +45,7 @@ class BST extends binary_tree_1.BinaryTree {
      * If the node was not added (e.g., due to a duplicate ID), it returns `null` or `undefined`.
      */
     add(id, val) {
+        // TODO support node as a param
         let inserted = null;
         const newNode = this.createNode(id, val);
         if (this.root === null) {

package/dist/data-structures/binary-tree/rb-tree.d.ts

@@ -2,7 +2,7 @@ import { BinaryTreeNodeId, RBColor, RBTreeNodeNested, RBTreeOptions } from '../t
 import { IRBTree, IRBTreeNode } from '../interfaces/rb-tree';
 import { BST, BSTNode } from './bst';
 export declare class RBTreeNode<T = any, NEIGHBOR extends RBTreeNode<T, NEIGHBOR> = RBTreeNodeNested<T>> extends BSTNode<T, NEIGHBOR> implements IRBTreeNode<T, NEIGHBOR> {
-    constructor(id: BinaryTreeNodeId, color: RBColor, val?: T);
+    constructor(id: BinaryTreeNodeId, val?: T, color?: RBColor);
     private _color;
     get color(): RBColor;
     set color(value: RBColor);

package/dist/data-structures/binary-tree/rb-tree.js

@@ -4,9 +4,8 @@ exports.RBTree = exports.RBTreeNode = void 0;
 const types_1 = require("../types");
 const bst_1 = require("./bst");
 class RBTreeNode extends bst_1.BSTNode {
-    constructor(id, color, val) {
+    constructor(id, val, color = types_1.RBColor.RED) {
         super(id, val);
-        this._color = types_1.RBColor.RED;
         this._color = color;
     }
     get color() {
@@ -22,7 +21,7 @@ class RBTree extends bst_1.BST {
         super(options);
     }
     createNode(id, val) {
-        return new RBTreeNode(id, types_1.RBColor.RED, val);
+        return new RBTreeNode(id, val, types_1.RBColor.RED);
     }
     // private override _root: BinaryTreeNode<N> | null = null;
     //

package/dist/data-structures/binary-tree/tree-multiset.d.ts

@@ -57,17 +57,16 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      */
     swapLocation(srcNode: N, destNode: N): N;
     /**
-     * The `add` function adds a new node to a binary tree, updating the size and count properties accordingly, and
-     * balancing the tree if necessary.
-     * @param {BinaryTreeNodeId} id - The id parameter represents the identifier of the binary tree node that we want to
-     * add. It is of type BinaryTreeNodeId.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. If no value is
-     * provided, it will default to `undefined`.
-     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the node
-     * with the given `id` should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
-     * @returns The `add` method returns the inserted node (`N`), `null`, or `undefined`.
-     */
-    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined;
+     * The `add` function adds a new node to a binary search tree, maintaining the tree's properties and balancing if
+     * necessary.
+     * @param {BinaryTreeNodeId | N} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId` or a `N` (which
+     * represents a `BinaryTreeNode`).
+     * @param [val] - The `val` parameter represents the value to be added to the binary tree node.
+     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
+     * value should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
+     * @returns The method `add` returns either the inserted node (`N`), `null`, or `undefined`.
+     */
+    add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val'], count?: number): N | null | undefined;
     /**
      * The function adds a new node to a binary tree as the left or right child of a given parent node.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
@@ -79,13 +78,20 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      */
     addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
-     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
-     * null/undefined values.
-     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
-     * array of `N` objects.
+     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes.
+     * @param {BinaryTreeNodeId[] | N[]} idsOrNodes - An array of BinaryTreeNodeId objects or N objects. These objects
+     * represent the IDs or nodes of the binary tree where the values will be added.
+     * @param {N['val'][]} [data] - Optional array of values to be associated with each node being added. If provided, the
+     * length of the `data` array should be equal to the length of the `idsOrNodes` array.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(data: N[] | Array<N['val']>): (N | null | undefined)[];
+    addMany(idsOrNodes: (BinaryTreeNodeId | N)[], data?: N['val'][]): (N | null | undefined)[];
+    /**
+     * The `perfectlyBalance` function takes a binary tree, performs a depth-first search to sort the nodes, and then
+     * constructs a balanced binary search tree using either a recursive or iterative approach.
+     * @returns The function `perfectlyBalance()` returns a boolean value.
+     */
+    perfectlyBalance(): boolean;
     /**
      * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
      * node that needs to be balanced.

package/dist/data-structures/binary-tree/tree-multiset.js

@@ -16,7 +16,6 @@ class TreeMultisetNode extends avl_tree_1.AVLTreeNode {
      */
     constructor(id, val, count = 1) {
         super(id, val);
-        this._count = 1;
         this._count = count;
     }
     get count() {
@@ -38,7 +37,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * TreeMultiset.
      */
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { isMergeDuplicatedVal: true }));
+        super(Object.assign(Object.assign({}, options), { isMergeDuplicatedNodeById: true }));
         this._count = 0;
     }
     get count() {
@@ -64,97 +63,98 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * @returns the `destNode` after swapping its values with the `srcNode`.
      */
     swapLocation(srcNode, destNode) {
-        const { val, count, height, id } = destNode;
+        const { id, val, count, height } = destNode;
         const tempNode = this.createNode(id, val, count);
         if (tempNode) {
             tempNode.height = height;
-            if (tempNode instanceof TreeMultisetNode) {
-                destNode.id = srcNode.id;
-                destNode.val = srcNode.val;
-                destNode.count = srcNode.count;
-                destNode.height = srcNode.height;
-                srcNode.id = tempNode.id;
-                srcNode.val = tempNode.val;
-                srcNode.count = tempNode.count;
-                srcNode.height = tempNode.height;
-            }
+            destNode.id = srcNode.id;
+            destNode.val = srcNode.val;
+            destNode.count = srcNode.count;
+            destNode.height = srcNode.height;
+            srcNode.id = tempNode.id;
+            srcNode.val = tempNode.val;
+            srcNode.count = tempNode.count;
+            srcNode.height = tempNode.height;
         }
         return destNode;
     }
     /**
-     * The `add` function adds a new node to a binary tree, updating the size and count properties accordingly, and
-     * balancing the tree if necessary.
-     * @param {BinaryTreeNodeId} id - The id parameter represents the identifier of the binary tree node that we want to
-     * add. It is of type BinaryTreeNodeId.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. If no value is
-     * provided, it will default to `undefined`.
-     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the node
-     * with the given `id` should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
-     * @returns The `add` method returns the inserted node (`N`), `null`, or `undefined`.
+     * The `add` function adds a new node to a binary search tree, maintaining the tree's properties and balancing if
+     * necessary.
+     * @param {BinaryTreeNodeId | N} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId` or a `N` (which
+     * represents a `BinaryTreeNode`).
+     * @param [val] - The `val` parameter represents the value to be added to the binary tree node.
+     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
+     * value should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
+     * @returns The method `add` returns either the inserted node (`N`), `null`, or `undefined`.
      */
-    add(id, val, count) {
+    add(idOrNode, val, count) {
         count = count !== null && count !== void 0 ? count : 1;
-        let inserted = null;
-        const newNode = this.createNode(id, val, count);
-        if (this.root === null) {
+        let inserted = undefined, newNode;
+        if (idOrNode instanceof TreeMultisetNode) {
+            newNode = this.createNode(idOrNode.id, idOrNode.val, idOrNode.count);
+        }
+        else if (idOrNode === null) {
+            newNode = null;
+        }
+        else {
+            newNode = this.createNode(idOrNode, val, count);
+        }
+        if (!this.root) {
             this._setRoot(newNode);
             this._setSize(this.size + 1);
-            this._setCount(this.count + count);
-            inserted = (this.root);
+            newNode && this._setCount(this.count + newNode.count);
+            inserted = this.root;
         }
         else {
             let cur = this.root;
             let traversing = true;
             while (traversing) {
-                if (cur !== null && newNode !== null) {
-                    if (this._compare(cur.id, id) === types_1.CP.eq) {
-                        if (newNode) {
+                if (cur) {
+                    if (newNode) {
+                        if (this._compare(cur.id, newNode.id) === types_1.CP.eq) {
                             cur.val = newNode.val;
-                            cur.count += count;
-                            this._setCount(this.count + newNode.count);
-                        }
-                        //Duplicates are not accepted.
-                        traversing = false;
-                        inserted = cur;
-                    }
-                    else if (this._compare(cur.id, id) === types_1.CP.gt) {
-                        // Traverse left of the node
-                        if (cur.left === undefined) {
-                            if (newNode) {
-                                newNode.parent = cur;
-                            }
-                            //Add to the left of the current node
-                            cur.left = newNode;
-                            this._setSize(this.size + 1);
+                            cur.count += newNode.count;
                             this._setCount(this.count + newNode.count);
                             traversing = false;
-                            inserted = cur.left;
+                            inserted = cur;
                         }
-                        else {
-                            //Traverse the left of the current node
-                            if (cur.left)
-                                cur = cur.left;
-                        }
-                    }
-                    else if (this._compare(cur.id, id) === types_1.CP.lt) {
-                        // Traverse right of the node
-                        if (cur.right === undefined) {
-                            if (newNode) {
-                                newNode.parent = cur;
+                        else if (this._compare(cur.id, newNode.id) === types_1.CP.gt) {
+                            // Traverse left of the node
+                            if (cur.left === undefined) {
+                                //Add to the left of the current node
+                                cur.left = newNode;
+                                this._setSize(this.size + 1);
+                                this._setCount(this.count + newNode.count);
+                                traversing = false;
+                                inserted = cur.left;
+                            }
+                            else {
+                                //Traverse the left of the current node
+                                if (cur.left)
+                                    cur = cur.left;
                             }
-                            //Add to the right of the current node
-                            cur.right = newNode;
-                            this._setSize(this.size + 1);
-                            this._setCount(this.count + newNode.count);
-                            traversing = false;
-                            inserted = (cur.right);
                         }
-                        else {
-                            //Traverse the left of the current node
-                            if (cur.right)
-                                cur = cur.right;
+                        else if (this._compare(cur.id, newNode.id) === types_1.CP.lt) {
+                            // Traverse right of the node
+                            if (cur.right === undefined) {
+                                //Add to the right of the current node
+                                cur.right = newNode;
+                                this._setSize(this.size + 1);
+                                this._setCount(this.count + newNode.count);
+                                traversing = false;
+                                inserted = (cur.right);
+                            }
+                            else {
+                                //Traverse the left of the current node
+                                if (cur.right)
+                                    cur = cur.right;
+                            }
                         }
                     }
+                    else {
+                        // TODO may need to support null inserted
+                    }
                 }
                 else {
                     traversing = false;
@@ -175,27 +175,20 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * `undefined` in certain cases.
      */
     addTo(newNode, parent) {
-        var _a, _b;
         if (parent) {
             if (parent.left === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                }
                 parent.left = newNode;
                 if (newNode !== null) {
                     this._setSize(this.size + 1);
-                    this._setCount((_a = this.count + newNode.count) !== null && _a !== void 0 ? _a : 0);
+                    this._setCount(this.count + newNode.count);
                 }
                 return parent.left;
             }
             else if (parent.right === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                }
                 parent.right = newNode;
                 if (newNode !== null) {
                     this._setSize(this.size + 1);
-                    this._setCount((_b = this.count + newNode.count) !== null && _b !== void 0 ? _b : 0);
+                    this._setCount(this.count + newNode.count);
                 }
                 return parent.right;
             }
@@ -208,66 +201,86 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         }
     }
     /**
-     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
-     * null/undefined values.
-     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
-     * array of `N` objects.
+     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes.
+     * @param {BinaryTreeNodeId[] | N[]} idsOrNodes - An array of BinaryTreeNodeId objects or N objects. These objects
+     * represent the IDs or nodes of the binary tree where the values will be added.
+     * @param {N['val'][]} [data] - Optional array of values to be associated with each node being added. If provided, the
+     * length of the `data` array should be equal to the length of the `idsOrNodes` array.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(data) {
+    addMany(idsOrNodes, data) {
         var _a;
         // TODO not sure addMany not be run multi times
         const inserted = [];
         const map = new Map();
-        if (this.isMergeDuplicatedVal) {
-            for (const nodeOrId of data)
-                map.set(nodeOrId, ((_a = map.get(nodeOrId)) !== null && _a !== void 0 ? _a : 0) + 1);
+        if (this.isMergeDuplicatedNodeById) {
+            for (const idOrNode of idsOrNodes)
+                map.set(idOrNode, ((_a = map.get(idOrNode)) !== null && _a !== void 0 ? _a : 0) + 1);
         }
-        for (const nodeOrId of data) {
-            if (nodeOrId instanceof TreeMultisetNode) {
-                inserted.push(this.add(nodeOrId.id, nodeOrId.val, nodeOrId.count));
+        for (let i = 0; i < idsOrNodes.length; i++) {
+            const idOrNode = idsOrNodes[i];
+            if (idOrNode instanceof TreeMultisetNode) {
+                inserted.push(this.add(idOrNode.id, idOrNode.val, idOrNode.count));
                 continue;
             }
-            if (nodeOrId === null) {
+            if (idOrNode === null) {
                 inserted.push(this.add(NaN, null, 0));
                 continue;
             }
-            // TODO will this cause an issue?
-            const count = this.isMergeDuplicatedVal ? map.get(nodeOrId) : 1;
-            let newId;
-            if (typeof nodeOrId === 'number') {
-                newId = this.autoIncrementId ? this.maxId + 1 : nodeOrId;
-            }
-            else if (nodeOrId instanceof Object) {
-                if (this.autoIncrementId) {
-                    newId = this.maxId + 1;
-                }
-                else {
-                    if (Object.keys(nodeOrId).includes('id')) {
-                        newId = nodeOrId.id;
-                    }
-                    else {
-                        console.warn(nodeOrId, 'Object value must has an id property when the autoIncrementId is false');
-                        continue;
-                    }
+            const count = this.isMergeDuplicatedNodeById ? map.get(idOrNode) : 1;
+            const val = data === null || data === void 0 ? void 0 : data[i];
+            if (this.isMergeDuplicatedNodeById) {
+                if (map.has(idOrNode)) {
+                    inserted.push(this.add(idOrNode, val, count));
+                    map.delete(idOrNode);
                 }
             }
             else {
-                console.warn(nodeOrId, ` is not added`);
-                continue;
+                inserted.push(this.add(idOrNode, val, 1));
             }
-            if (this.isMergeDuplicatedVal) {
-                if (map.has(nodeOrId)) {
-                    inserted.push(this.add(newId, nodeOrId, count));
-                    map.delete(nodeOrId);
+        }
+        return inserted;
+    }
+    /**
+     * The `perfectlyBalance` function takes a binary tree, performs a depth-first search to sort the nodes, and then
+     * constructs a balanced binary search tree using either a recursive or iterative approach.
+     * @returns The function `perfectlyBalance()` returns a boolean value.
+     */
+    perfectlyBalance() {
+        const sorted = this.DFS('in', 'node'), n = sorted.length;
+        if (sorted.length < 1)
+            return false;
+        this.clear();
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
+            const buildBalanceBST = (l, r) => {
+                if (l > r)
+                    return;
+                const m = l + Math.floor((r - l) / 2);
+                const midNode = sorted[m];
+                this.add(midNode.id, midNode.val, midNode.count);
+                buildBalanceBST(l, m - 1);
+                buildBalanceBST(m + 1, r);
+            };
+            buildBalanceBST(0, n - 1);
+            return true;
+        }
+        else {
+            const stack = [[0, n - 1]];
+            while (stack.length > 0) {
+                const popped = stack.pop();
+                if (popped) {
+                    const [l, r] = popped;
+                    if (l <= r) {
+                        const m = l + Math.floor((r - l) / 2);
+                        const midNode = sorted[m];
+                        this.add(midNode.id, midNode.val, midNode.count);
+                        stack.push([m + 1, r]);
+                        stack.push([l, m - 1]);
+                    }
                 }
             }
-            else {
-                inserted.push(this.add(newId, nodeOrId, 1));
-            }
-            this._setMaxId(newId);
+            return true;
         }
-        return inserted;
     }
     /**
      * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
@@ -282,7 +295,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = (typeof nodeOrId === 'number') ? this.get(nodeOrId) : nodeOrId;
+        const curr = this.get(nodeOrId);
         if (!curr)
             return bstDeletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
@@ -314,15 +327,18 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
                     orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
-                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
                             parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-                        else
+                        }
+                        else {
                             parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+                        }
                         needBalanced = parentOfLeftSubTreeMax;
                     }
                 }
             }
             this._setSize(this.size - 1);
+            // TODO How to handle when the count of target node is lesser than current node's count
             this._setCount(this.count - orgCurrent.count);
         }
         bstDeletedResult.push({ deleted: orgCurrent, needBalanced });

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

@@ -25,7 +25,8 @@ export declare class HeapItem<T = number> {
 }
 export declare abstract class Heap<T = number> {
     /**
-     * The constructor function initializes a priority queue with an optional priority extractor function.
+     * The function is a constructor for a class that initializes a priority callback function based on the
+     * options provided.
      * @param [options] - An optional object that contains configuration options for the Heap.
      */
     protected constructor(options?: HeapOptions<T>);
@@ -64,8 +65,8 @@ export declare abstract class Heap<T = number> {
     poll(isItem: false): T | undefined;
     poll(isItem: true): HeapItem<T> | null;
     /**
-     * The `has` function checks if a given node or value exists in the priority queue.
-     * @param {T | HeapItem<T>} node - The `node` parameter can be of type `T` or `HeapItem<T>`.
+     * 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.
      */
     has(node: T | HeapItem<T>): boolean;

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

@@ -29,7 +29,8 @@ class HeapItem {
 exports.HeapItem = HeapItem;
 class Heap {
     /**
-     * The constructor function initializes a priority queue with an optional priority extractor function.
+     * The function is a constructor for a class that initializes a priority callback function based on the
+     * options provided.
      * @param [options] - An optional object that contains configuration options for the Heap.
      */
     constructor(options) {
@@ -65,14 +66,8 @@ class Heap {
         return this._pq.size < 1;
     }
     /**
-     * The `peek` function returns the top item or value in a priority queue, depending on the value of the `isItem`
-     * parameter.
-     * @param {boolean} [isItem] - The `isItem` parameter is an optional boolean parameter that determines whether the
-     * method should return the entire `HeapItem` object or just the value of the item. If `isItem` is set to `true`, the
-     * method will return the `HeapItem` object. If `isItem`
-     * @returns The `peek` method returns either a `HeapItem<T>` object, `null`, `T`, or `undefined`. The specific return
-     * type depends on the value of the `isItem` parameter. If `isItem` is `true`, then the method returns a `HeapItem<T>`
-     * object or `null` if the heap is empty. If `isItem` is `false`
+     * 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 val with the highest priority in the queue
      */
     peek(isItem) {
         isItem = isItem !== null && isItem !== void 0 ? isItem : false;
@@ -80,14 +75,8 @@ class Heap {
         return isItem ? peeked : peeked === null || peeked === void 0 ? void 0 : peeked.val;
     }
     /**
-     * The `peekLast` function returns the last item in the heap, either as a `HeapItem` object or just the value depending
-     * on the `isItem` parameter.
-     * @param {boolean} [isItem] - A boolean parameter that indicates whether the method should return the HeapItem object
-     * or just the value of the last item in the heap. If isItem is true, the method will return the HeapItem object. If
-     * isItem is false or not provided, the method will return the value of the last item
-     * @returns The method `peekLast` returns either a `HeapItem<T>` object, `null`, `T`, or `undefined`. The specific
-     * return type depends on the value of the `isItem` parameter. If `isItem` is `true`, then the method returns a
-     * `HeapItem<T>` object or `null` if there are no items in the heap. If `isItem`
+     * The `peekLast` function returns the last item in the heap.
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
     peekLast(isItem) {
         isItem = isItem !== null && isItem !== void 0 ? isItem : false;
@@ -110,13 +99,8 @@ class Heap {
         return this;
     }
     /**
-     * The `poll` function returns the top item from a priority queue, either as a HeapItem object or its value, depending
-     * on the value of the `isItem` parameter.
-     * @param {boolean} [isItem] - The `isItem` parameter is a boolean flag that indicates whether the returned value
-     * should be a `HeapItem<T>` object or just the value `T` itself. If `isItem` is `true`, the method will return the
-     * `HeapItem<T>` object, otherwise it will return just
-     * @returns The function `poll` returns either a `HeapItem<T>` object, `null`, or `T` (the value of the `val` property
-     * of the `HeapItem<T>` object).
+     * 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.
      */
     poll(isItem) {
         isItem = isItem !== null && isItem !== void 0 ? isItem : false;
@@ -127,8 +111,8 @@ class Heap {
         return isItem ? top : top.val;
     }
     /**
-     * The `has` function checks if a given node or value exists in the priority queue.
-     * @param {T | HeapItem<T>} node - The `node` parameter can be of type `T` or `HeapItem<T>`.
+     * 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.
      */
     has(node) {
@@ -142,13 +126,8 @@ class Heap {
         }
     }
     /**
-     * The `toArray` function returns an array of either HeapItem objects or their values, depending on the value of the
-     * `isItem` parameter.
-     * @param {boolean} [isItem] - isItem is an optional boolean parameter that determines whether the returned array
-     * should contain the HeapItem objects or just the values of the HeapItem objects. If isItem is true, the array will
-     * contain the HeapItem objects. If isItem is false or not provided, the array will contain only the values
-     * @returns The method `toArray` returns an array of `HeapItem<T>` objects, or an array of `T` values if the `isItem`
-     * parameter is set to `false`.
+     * The `toArray` function returns an array of `HeapItem<T>` objects.
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
     toArray(isItem) {
         isItem = isItem !== null && isItem !== void 0 ? isItem : false;