data-structure-typed 1.33.0 → 1.33.5

package/docs/modules.html

@@ -49,6 +49,7 @@
 <a href="classes/DirectedVertex.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Directed<wbr/>Vertex</span></a>
 <a href="classes/DoublyLinkedList.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Doubly<wbr/>Linked<wbr/>List</span></a>
 <a href="classes/DoublyLinkedListNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Doubly<wbr/>Linked<wbr/>List<wbr/>Node</span></a>
+<a href="classes/HashNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Node</span></a>
 <a href="classes/HashTable.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Table</span></a>
 <a href="classes/Heap.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Heap</span></a>
 <a href="classes/HeapItem.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Heap<wbr/>Item</span></a>
@@ -216,6 +217,7 @@
 <li><a href="classes/DirectedVertex.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Directed<wbr/>Vertex</span></a></li>
 <li><a href="classes/DoublyLinkedList.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Doubly<wbr/>Linked<wbr/>List</span></a></li>
 <li><a href="classes/DoublyLinkedListNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Doubly<wbr/>Linked<wbr/>List<wbr/>Node</span></a></li>
+<li><a href="classes/HashNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Node</span></a></li>
 <li><a href="classes/HashTable.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Table</span></a></li>
 <li><a href="classes/Heap.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Heap</span></a></li>
 <li><a href="classes/HeapItem.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Heap<wbr/>Item</span></a></li>

package/lib/data-structures/binary-tree/abstract-binary-tree.d.ts

@@ -8,21 +8,21 @@
 import type { AbstractBinaryTreeNodeNested, AbstractBinaryTreeNodeProperties, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName } from '../../types';
 import { AbstractBinaryTreeOptions, FamilyPosition, LoopType } from '../../types';
 import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from '../../interfaces';
-export declare abstract class AbstractBinaryTreeNode<T = any, NEIGHBOR extends AbstractBinaryTreeNode<T, NEIGHBOR> = AbstractBinaryTreeNodeNested<T>> implements IAbstractBinaryTreeNode<T, NEIGHBOR> {
+export declare abstract class AbstractBinaryTreeNode<V = any, NEIGHBOR extends AbstractBinaryTreeNode<V, NEIGHBOR> = AbstractBinaryTreeNodeNested<V>> implements IAbstractBinaryTreeNode<V, NEIGHBOR> {
     /**
      * The constructor function initializes a BinaryTreeNode object with an id and an optional value.
      * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
      * of the binary tree node. It is used to distinguish one node from another in the binary tree.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It represents the value that will be
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It represents the value that will be
      * stored in the binary tree node. If no value is provided, it will be set to undefined.
      */
-    protected constructor(id: BinaryTreeNodeId, val?: T);
+    protected constructor(id: BinaryTreeNodeId, val?: V);
     private _id;
     get id(): BinaryTreeNodeId;
     set id(v: BinaryTreeNodeId);
     private _val;
-    get val(): T | undefined;
-    set val(value: T | undefined);
+    get val(): V | undefined;
+    set val(value: V | undefined);
     private _left;
     get left(): NEIGHBOR | null | undefined;
     set left(v: NEIGHBOR | null | undefined);
@@ -60,8 +60,6 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     get visitedVal(): N['val'][];
     private _visitedNode;
     get visitedNode(): N[];
-    private _visitedLeftSum;
-    get visitedLeftSum(): number[];
     abstract createNode(id: BinaryTreeNodeId, val?: N['val']): N | null;
     /**
      * The `swapLocation` function swaps the location of two nodes in a binary tree.
@@ -116,16 +114,13 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     fill(idsOrNodes: (BinaryTreeNodeId | null)[] | (N | null)[], data?: N[] | Array<N['val']>): 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.
+     * The `remove` function in TypeScript is used to delete a node from a binary search tree and returns an array of objects
+     * containing the deleted node and the node that needs to be balanced.
      * @param {N | BinaryTreeNodeId} nodeOrId - The `nodeOrId` parameter can be either a node object (`N`) or a binary tree
      * node ID (`BinaryTreeNodeId`).
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean parameter that
-     * determines whether to update the left sum of all nodes in the binary tree after removing a node. If
-     * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be updated. If it
      * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(nodeOrId: N | BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
+    remove(nodeOrId: N | BinaryTreeNodeId): BinaryTreeDeletedResult<N>[];
     /**
      * The function calculates the depth of a node in a binary tree.
      * @param {N | BinaryTreeNodeId | null} beginRoot - The `beginRoot` parameter can be one of the following:
@@ -476,11 +471,6 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @param {N[]} value - N[] is an array of elements of type N.
      */
     protected _setVisitedNode(value: N[]): void;
-    /**
-     * The function sets the value of the `_visitedLeftSum` property to the provided array.
-     * @param {number[]} value - An array of numbers that represents the visited left sum.
-     */
-    protected _setVisitedLeftSum(value: number[]): void;
     /**
      * The function sets the root property of an object to a given value, and if the value is not null, it also sets the
      * parent property of the value to undefined.

package/lib/data-structures/binary-tree/abstract-binary-tree.js

@@ -12,7 +12,7 @@ export class AbstractBinaryTreeNode {
      * The constructor function initializes a BinaryTreeNode object with an id and an optional value.
      * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
      * of the binary tree node. It is used to distinguish one node from another in the binary tree.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It represents the value that will be
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It represents the value that will be
      * stored in the binary tree node. If no value is provided, it will be set to undefined.
      */
     constructor(id, val) {
@@ -106,13 +106,13 @@ export class AbstractBinaryTree {
      * tree.
      */
     constructor(options) {
+        // TODO placeholder node may need redesigned
         this._root = null;
         this._size = 0;
         this._loopType = LoopType.ITERATIVE;
         this._visitedId = [];
         this._visitedVal = [];
         this._visitedNode = [];
-        this._visitedLeftSum = [];
         if (options !== undefined) {
             const { loopType = LoopType.ITERATIVE } = options;
             this._loopType = loopType;
@@ -137,9 +137,6 @@ export class AbstractBinaryTree {
     get visitedNode() {
         return this._visitedNode;
     }
-    get visitedLeftSum() {
-        return this._visitedLeftSum;
-    }
     /**
      * The `swapLocation` function swaps the location of two nodes in a binary tree.
      * @param {N} srcNode - The source node that you want to swap with the destination node.
@@ -287,20 +284,13 @@ export class AbstractBinaryTree {
         return idsOrNodes.length === this.addMany(idsOrNodes, data).length;
     }
     /**
-     * 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.
+     * The `remove` function in TypeScript is used to delete a node from a binary search tree and returns an array of objects
+     * containing the deleted node and the node that needs to be balanced.
      * @param {N | BinaryTreeNodeId} nodeOrId - The `nodeOrId` parameter can be either a node object (`N`) or a binary tree
      * node ID (`BinaryTreeNodeId`).
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean parameter that
-     * determines whether to update the left sum of all nodes in the binary tree after removing a node. If
-     * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be updated. If it
      * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(nodeOrId, isUpdateAllLeftSum) {
-        isUpdateAllLeftSum = isUpdateAllLeftSum === undefined ? true : isUpdateAllLeftSum;
-        // TODO may implement update all left sum
-        if (isUpdateAllLeftSum) {
-        }
+    remove(nodeOrId) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
@@ -1168,13 +1158,6 @@ export class AbstractBinaryTree {
     _setVisitedNode(value) {
         this._visitedNode = value;
     }
-    /**
-     * The function sets the value of the `_visitedLeftSum` property to the provided array.
-     * @param {number[]} value - An array of numbers that represents the visited left sum.
-     */
-    _setVisitedLeftSum(value) {
-        this._visitedLeftSum = value;
-    }
     /**
      * The function sets the root property of an object to a given value, and if the value is not null, it also sets the
      * parent property of the value to undefined.
@@ -1201,7 +1184,6 @@ export class AbstractBinaryTree {
         this._visitedId = [];
         this._visitedVal = [];
         this._visitedNode = [];
-        this._visitedLeftSum = [];
     }
     /**
      * The function checks if a given property of a binary tree node matches a specified value, and if so, adds the node to

package/lib/data-structures/binary-tree/avl-tree.d.ts

@@ -8,8 +8,8 @@
 import { BST, BSTNode } from './bst';
 import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeId } from '../../types';
 import { IAVLTree, IAVLTreeNode } from '../../interfaces';
-export declare class AVLTreeNode<T = any, NEIGHBOR extends AVLTreeNode<T, NEIGHBOR> = AVLTreeNodeNested<T>> extends BSTNode<T, NEIGHBOR> implements IAVLTreeNode<T, NEIGHBOR> {
-    constructor(id: BinaryTreeNodeId, val?: T);
+export declare class AVLTreeNode<V = any, NEIGHBOR extends AVLTreeNode<V, NEIGHBOR> = AVLTreeNodeNested<V>> extends BSTNode<V, NEIGHBOR> implements IAVLTreeNode<V, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: V);
 }
 export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends BST<N> implements IAVLTree<N> {
     /**
@@ -37,16 +37,13 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      */
     add(id: BinaryTreeNodeId, val?: N['val']): N | null | undefined;
     /**
-     * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
-     * then balances the tree if necessary.
+     * The function overrides the remove method of a binary tree and performs additional operations to balance the tree after
+     * deletion.
      * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
-     * removed from the AVL tree.
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean parameter that
-     * determines whether the left sum of all nodes in the AVL tree should be updated after removing a node. If
-     * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be recalculated.
-     * @returns The method is returning an array of `AVLTreeDeleted<N>` objects.
+     * removed.
+     * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
+    remove(id: BinaryTreeNodeId): BinaryTreeDeletedResult<N>[];
     /**
      * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
      * height of its right subtree.

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

@@ -47,17 +47,14 @@ export class AVLTree extends BST {
         return inserted;
     }
     /**
-     * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
-     * then balances the tree if necessary.
+     * The function overrides the remove method of a binary tree and performs additional operations to balance the tree after
+     * deletion.
      * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
-     * removed from the AVL tree.
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean parameter that
-     * determines whether the left sum of all nodes in the AVL tree should be updated after removing a node. If
-     * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be recalculated.
-     * @returns The method is returning an array of `AVLTreeDeleted<N>` objects.
+     * removed.
+     * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(id, isUpdateAllLeftSum) {
-        const deletedResults = super.remove(id, isUpdateAllLeftSum);
+    remove(id) {
+        const deletedResults = super.remove(id);
         for (const { needBalanced } of deletedResults) {
             if (needBalanced) {
                 this._balancePath(needBalanced);

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

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

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

@@ -9,8 +9,8 @@ import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTNo
 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 BSTNode<V = any, NEIGHBOR extends BSTNode<V, NEIGHBOR> = BSTNodeNested<V>> extends BinaryTreeNode<V, NEIGHBOR> implements IBSTNode<V, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: V);
 }
 export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
     /**

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

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

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

@@ -1,9 +1,9 @@
 import { RBColor } from '../../types';
 import { BST, BSTNode } from './bst';
 export class RBTreeNode extends BSTNode {
-    constructor(id, val, color = RBColor.RED) {
+    constructor(id, val) {
         super(id, val);
-        this._color = color;
+        this._color = RBColor.RED;
     }
     get color() {
         return this._color;
@@ -17,6 +17,6 @@ export class RBTree extends BST {
         super(options);
     }
     createNode(id, val) {
-        return new RBTreeNode(id, val, RBColor.RED);
+        return new RBTreeNode(id, val);
     }
 }

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

@@ -9,18 +9,18 @@ import type { BinaryTreeNodeId, TreeMultisetNodeNested, TreeMultisetOptions } fr
 import { BinaryTreeDeletedResult, DFSOrderPattern } from '../../types';
 import { ITreeMultiset, ITreeMultisetNode } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultisetNode<T = any, NEIGHBOR extends TreeMultisetNode<T, NEIGHBOR> = TreeMultisetNodeNested<T>> extends AVLTreeNode<T, NEIGHBOR> implements ITreeMultisetNode<T, NEIGHBOR> {
+export declare class TreeMultisetNode<V = any, NEIGHBOR extends TreeMultisetNode<V, NEIGHBOR> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, NEIGHBOR> implements ITreeMultisetNode<V, NEIGHBOR> {
     /**
      * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
      * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
      * of the binary tree node.
-     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value of the binary
+     * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
      * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
      * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
      * parameter when creating a new instance of the `BinaryTreeNode` class,
      */
-    constructor(id: BinaryTreeNodeId, val?: T, count?: number);
+    constructor(id: BinaryTreeNodeId, val?: V, count?: number);
     private _count;
     get count(): number;
     set count(v: number);

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

@@ -5,7 +5,7 @@ export class TreeMultisetNode extends AVLTreeNode {
      * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
      * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
      * of the binary tree node.
-     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value of the binary
+     * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
      * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
      * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`

package/lib/data-structures/graph/abstract-graph.d.ts

@@ -1,35 +1,35 @@
 import type { DijkstraResult, VertexId } from '../../types';
 import { IAbstractGraph } from '../../interfaces';
-export declare abstract class AbstractVertex<T = any> {
+export declare abstract class AbstractVertex<V = any> {
     /**
      * The function is a protected constructor that takes an id and an optional value as parameters.
      * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex object.
-     * @param {T} [val] - The parameter "val" is an optional parameter of type T. It is used to assign a value to the
+     * @param {V} [val] - The parameter "val" is an optional parameter of type V. It is used to assign a value to the
      * vertex. If no value is provided, it will be set to undefined.
      */
-    protected constructor(id: VertexId, val?: T);
+    protected constructor(id: VertexId, val?: V);
     private _id;
     get id(): VertexId;
     set id(v: VertexId);
     private _val;
-    get val(): T | undefined;
-    set val(value: T | undefined);
+    get val(): V | undefined;
+    set val(value: V | undefined);
 }
-export declare abstract class AbstractEdge<T = any> {
+export declare abstract class AbstractEdge<V = any> {
     /**
      * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
      * object.
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the object. If
      * a value is provided, it will be assigned to the `_weight` property. If no value is provided, the default value of 1
      * will be assigned.
-     * @param {T} [val] - The `val` parameter is of type `T`, which means it can be any type. It is an optional parameter,
+     * @param {V} [val] - The `val` parameter is of type `V`, which means it can be any type. It is an optional parameter,
      * meaning it can be omitted when creating an instance of the class.
      */
-    protected constructor(weight?: number, val?: T);
+    protected constructor(weight?: number, val?: V);
     private _val;
-    get val(): T | undefined;
-    set val(value: T | undefined);
+    get val(): V | undefined;
+    set val(value: V | undefined);
     private _weight;
     get weight(): number;
     set weight(v: number);

package/lib/data-structures/graph/abstract-graph.js

@@ -12,7 +12,7 @@ export class AbstractVertex {
      * The function is a protected constructor that takes an id and an optional value as parameters.
      * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex object.
-     * @param {T} [val] - The parameter "val" is an optional parameter of type T. It is used to assign a value to the
+     * @param {V} [val] - The parameter "val" is an optional parameter of type V. It is used to assign a value to the
      * vertex. If no value is provided, it will be set to undefined.
      */
     constructor(id, val) {
@@ -39,7 +39,7 @@ export class AbstractEdge {
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the object. If
      * a value is provided, it will be assigned to the `_weight` property. If no value is provided, the default value of 1
      * will be assigned.
-     * @param {T} [val] - The `val` parameter is of type `T`, which means it can be any type. It is an optional parameter,
+     * @param {V} [val] - The `val` parameter is of type `V`, which means it can be any type. It is an optional parameter,
      * meaning it can be omitted when creating an instance of the class.
      */
     constructor(weight, val) {

package/lib/data-structures/graph/directed-graph.d.ts

@@ -1,17 +1,17 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { VertexId } from '../../types';
 import { IDirectedGraph } from '../../interfaces';
-export declare class DirectedVertex<T = number> extends AbstractVertex<T> {
+export declare class DirectedVertex<V = any> extends AbstractVertex<V> {
     /**
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or data structure.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to initialize the value of the
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(id: VertexId, val?: T);
+    constructor(id: VertexId, val?: V);
 }
-export declare class DirectedEdge<T = number> extends AbstractEdge<T> {
+export declare class DirectedEdge<V = any> extends AbstractEdge<V> {
     /**
      * The constructor function initializes the source and destination vertices of an edge, along with an optional weight
      * and value.
@@ -20,10 +20,10 @@ export declare class DirectedEdge<T = number> extends AbstractEdge<T> {
      * @param {VertexId} dest - The `dest` parameter represents the destination vertex of an edge. It is of type
      * `VertexId`, which is likely a unique identifier for a vertex in a graph.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value associated with
+     * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value associated with
      * the edge.
      */
-    constructor(src: VertexId, dest: VertexId, weight?: number, val?: T);
+    constructor(src: VertexId, dest: VertexId, weight?: number, val?: V);
     private _src;
     get src(): VertexId;
     set src(v: VertexId);

package/lib/data-structures/graph/directed-graph.js

@@ -12,7 +12,7 @@ export class DirectedVertex extends AbstractVertex {
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or data structure.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to initialize the value of the
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
     constructor(id, val) {
@@ -28,7 +28,7 @@ export class DirectedEdge extends AbstractEdge {
      * @param {VertexId} dest - The `dest` parameter represents the destination vertex of an edge. It is of type
      * `VertexId`, which is likely a unique identifier for a vertex in a graph.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value associated with
+     * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value associated with
      * the edge.
      */
     constructor(src, dest, weight, val) {

package/lib/data-structures/graph/map-graph.d.ts

@@ -1,6 +1,6 @@
 import { MapGraphCoordinate, VertexId } from '../../types';
 import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
-export declare class MapVertex<T = any> extends DirectedVertex<T> {
+export declare class MapVertex<V = any> extends DirectedVertex<V> {
     /**
      * The constructor function initializes an object with an id, latitude, longitude, and an optional value.
      * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex.
@@ -10,10 +10,10 @@ export declare class MapVertex<T = any> extends DirectedVertex<T> {
      * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
      * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
      * values ranging from -180 to 180.
-     * @param {T} [val] - The "val" parameter is an optional value of type T. It is not required to be provided when
+     * @param {V} [val] - The "val" parameter is an optional value of type V. It is not required to be provided when
      * creating an instance of the class.
      */
-    constructor(id: VertexId, lat: number, long: number, val?: T);
+    constructor(id: VertexId, lat: number, long: number, val?: V);
     private _lat;
     get lat(): number;
     set lat(value: number);
@@ -21,7 +21,7 @@ export declare class MapVertex<T = any> extends DirectedVertex<T> {
     get long(): number;
     set long(value: number);
 }
-export declare class MapEdge<T = any> extends DirectedEdge<T> {
+export declare class MapEdge<V = any> extends DirectedEdge<V> {
     /**
      * The constructor function initializes a new instance of a class with the given source, destination, weight, and
      * value.
@@ -29,10 +29,10 @@ export declare class MapEdge<T = any> extends DirectedEdge<T> {
      * a graph.
      * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to store additional
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store additional
      * information or data associated with the edge.
      */
-    constructor(src: VertexId, dest: VertexId, weight?: number, val?: T);
+    constructor(src: VertexId, dest: VertexId, weight?: number, val?: V);
 }
 export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEdge = MapEdge> extends DirectedGraph<V, E> {
     /**

package/lib/data-structures/graph/map-graph.js

@@ -9,7 +9,7 @@ export class MapVertex extends DirectedVertex {
      * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
      * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
      * values ranging from -180 to 180.
-     * @param {T} [val] - The "val" parameter is an optional value of type T. It is not required to be provided when
+     * @param {V} [val] - The "val" parameter is an optional value of type V. It is not required to be provided when
      * creating an instance of the class.
      */
     constructor(id, lat, long, val) {
@@ -38,7 +38,7 @@ export class MapEdge extends DirectedEdge {
      * a graph.
      * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to store additional
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store additional
      * information or data associated with the edge.
      */
     constructor(src, dest, weight, val) {

package/lib/data-structures/graph/undirected-graph.d.ts

@@ -1,17 +1,17 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { VertexId } from '../../types';
 import { IUNDirectedGraph } from '../../interfaces';
-export declare class UndirectedVertex<T = number> extends AbstractVertex<T> {
+export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     /**
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or network.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to initialize the value of the
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(id: VertexId, val?: T);
+    constructor(id: VertexId, val?: V);
 }
-export declare class UndirectedEdge<T = number> extends AbstractEdge<T> {
+export declare class UndirectedEdge<V = number> extends AbstractEdge<V> {
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -19,10 +19,10 @@ export declare class UndirectedEdge<T = number> extends AbstractEdge<T> {
      * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
      * graph edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to store a value associated
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store a value associated
      * with the edge.
      */
-    constructor(v1: VertexId, v2: VertexId, weight?: number, val?: T);
+    constructor(v1: VertexId, v2: VertexId, weight?: number, val?: V);
     private _vertices;
     get vertices(): [VertexId, VertexId];
     set vertices(v: [VertexId, VertexId]);

package/lib/data-structures/graph/undirected-graph.js

@@ -12,7 +12,7 @@ export class UndirectedVertex extends AbstractVertex {
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or network.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to initialize the value of the
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
     constructor(id, val) {
@@ -27,7 +27,7 @@ export class UndirectedEdge extends AbstractEdge {
      * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
      * graph edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to store a value associated
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store a value associated
      * with the edge.
      */
     constructor(v1, v2, weight, val) {

package/lib/data-structures/hash/hash-table.d.ts

@@ -1,2 +1,62 @@
-export declare class HashTable {
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export declare class HashNode<K, V> {
+    key: K;
+    val: V;
+    next: HashNode<K, V> | null;
+    constructor(key: K, val: V);
+}
+export declare class HashTable<K, V> {
+    get buckets(): Array<HashNode<K, V> | null>;
+    set buckets(value: Array<HashNode<K, V> | null>);
+    get size(): number;
+    set size(value: number);
+    get capacity(): number;
+    set capacity(value: number);
+    private _capacity;
+    private _size;
+    private _buckets;
+    /**
+     * The constructor initializes the capacity, size, and buckets of an object.
+     * @param [capacity=1000] - The `capacity` parameter represents the maximum number of elements that the data structure
+     * can hold. It is an optional parameter with a default value of 1000.
+     */
+    constructor(capacity?: number);
+    /**
+     * The hash function takes a key, converts it to a string, calculates the sum of the ASCII values of its characters, and
+     * returns the remainder when divided by the capacity of the data structure.
+     * @param {K} key - The `key` parameter represents the key that needs to be hashed. It is of type `K`, which means it can
+     * be any data type that can be converted to a string.
+     * @returns The hash value of the key modulo the capacity of the data structure.
+     */
+    private hash;
+    /**
+     * The put function adds a key-value pair to a hash table, handling collisions by chaining.
+     * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
+     * table. It is of type K, which can be any data type that can be used as a key, such as a string, number, or object.
+     * @param {V} val - The `val` parameter represents the value associated with the key in the hash table.
+     * @returns Nothing is being returned. The return type of the function is void, which means it does not return any value.
+     */
+    put(key: K, val: V): void;
+    /**
+     * The `get` function retrieves the value associated with a given key from a hash table.
+     * @param {K} key - The parameter "key" represents the key of the element that we want to retrieve from the data
+     * structure.
+     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
+     * not found, it returns `undefined`.
+     */
+    get(key: K): V | undefined;
+    /**
+     * The `remove` function removes a key-value pair from a hash table.
+     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
+     * table.
+     * @returns Nothing is being returned. The `remove` method has a return type of `void`, which means it does not return
+     * any value.
+     */
+    remove(key: K): void;
 }