heap-typed 1.38.0 → 1.38.1

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

@@ -20,15 +20,6 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      * options.
      */
     constructor(options?: AVLTreeOptions);
-    /**
-     * The function swaps the key, value, and height properties between two nodes in a binary tree.
-     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
-     * with the `destNode`.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-     * from the source node (`srcNode`) will be swapped to.
-     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     */
-    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function creates a new AVL tree node with the specified key and value.
      * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
@@ -57,6 +48,15 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
     delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+    /**
+     * The function swaps the key, value, and height properties between two nodes in a binary tree.
+     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
+     * with the `destNode`.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from the source node (`srcNode`) will be swapped to.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function calculates the balance factor of a node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree data structure.

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

@@ -26,28 +26,6 @@ class AVLTree extends bst_1.BST {
     constructor(options) {
         super(options);
     }
-    /**
-     * The function swaps the key, value, and height properties between two nodes in a binary tree.
-     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
-     * with the `destNode`.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-     * from the source node (`srcNode`) will be swapped to.
-     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     */
-    _swap(srcNode, destNode) {
-        const { key, val, height } = destNode;
-        const tempNode = this.createNode(key, val);
-        if (tempNode) {
-            tempNode.height = height;
-            destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
-            destNode.height = srcNode.height;
-            srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
-            srcNode.height = tempNode.height;
-        }
-        return destNode;
-    }
     /**
      * The function creates a new AVL tree node with the specified key and value.
      * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
@@ -92,6 +70,28 @@ class AVLTree extends bst_1.BST {
         }
         return deletedResults;
     }
+    /**
+     * The function swaps the key, value, and height properties between two nodes in a binary tree.
+     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
+     * with the `destNode`.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from the source node (`srcNode`) will be swapped to.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    _swap(srcNode, destNode) {
+        const { key, val, height } = destNode;
+        const tempNode = this.createNode(key, val);
+        if (tempNode) {
+            tempNode.height = height;
+            destNode.key = srcNode.key;
+            destNode.val = srcNode.val;
+            destNode.height = srcNode.height;
+            srcNode.key = tempNode.key;
+            srcNode.val = tempNode.val;
+            srcNode.height = tempNode.height;
+        }
+        return destNode;
+    }
     /**
      * The function calculates the balance factor of a node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree data structure.

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

@@ -14,12 +14,6 @@ import { IBinaryTree } from '../../interfaces';
  * @template FAMILY - The type of the family relationship in the binary tree.
  */
 export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FAMILY> = BinaryTreeNodeNested<V>> {
-    /**
-     * Creates a new instance of BinaryTreeNode.
-     * @param {BinaryTreeNodeKey} key - The key associated with the node.
-     * @param {V} val - The value stored in the node.
-     */
-    constructor(key: BinaryTreeNodeKey, val?: V);
     /**
      * The key associated with the node.
      */
@@ -28,6 +22,16 @@ export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FA
      * The value stored in the node.
      */
     val: V | undefined;
+    /**
+     * The parent node of the current node.
+     */
+    parent: FAMILY | null | undefined;
+    /**
+     * Creates a new instance of BinaryTreeNode.
+     * @param {BinaryTreeNodeKey} key - The key associated with the node.
+     * @param {V} val - The value stored in the node.
+     */
+    constructor(key: BinaryTreeNodeKey, val?: V);
     private _left;
     /**
      * Get the left child node.
@@ -48,10 +52,6 @@ export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FA
      * @param {FAMILY | null | undefined} v - The right child node.
      */
     set right(v: FAMILY | null | undefined);
-    /**
-     * The parent node of the current node.
-     */
-    parent: FAMILY | null | undefined;
     /**
      * Get the position of the node within its family.
      * @returns {FamilyPosition} - The family position of the node.
@@ -63,18 +63,12 @@ export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FA
  * @template N - The type of the binary tree's nodes.
  */
 export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> implements IBinaryTree<N> {
+    private _loopType;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options?: BinaryTreeOptions);
-    /**
-     * Creates a new instance of BinaryTreeNode with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The key for the new node.
-     * @param {N['val']} val - The value for the new node.
-     * @returns {N} - The newly created BinaryTreeNode.
-     */
-    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     private _root;
     /**
      * Get the root node of the binary tree.
@@ -85,7 +79,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * Get the number of nodes in the binary tree.
      */
     get size(): number;
-    private _loopType;
     /**
      * Get the iteration type used in the binary tree.
      */
@@ -96,12 +89,12 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      */
     set iterationType(v: IterationType);
     /**
-     * Swap the data of two nodes in the binary tree.
-     * @param {N} srcNode - The source node to swap.
-     * @param {N} destNode - The destination node to swap.
-     * @returns {N} - The destination node after the swap.
+     * Creates a new instance of BinaryTreeNode with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The key for the new node.
+     * @param {N['val']} val - The value for the new node.
+     * @returns {N} - The newly created BinaryTreeNode.
      */
-    protected _swap(srcNode: N, destNode: N): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -174,7 +167,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @returns the height of the binary tree.
      */
     getHeight(beginRoot?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): number;
-    protected _defaultCallbackByKey: MapCallback<N>;
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
@@ -359,13 +351,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @returns The function `getPredecessor` returns the predecessor node of the given node `node`.
      */
     getPredecessor(node: N): N;
-    /**
-     * Time complexity is O(n)
-     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-     * the tree's structure should be restored to its original state to maintain the tree's integrity.
-     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-     */
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
      * algorithm and returns an array of values obtained by applying a callback function to each node.
@@ -381,6 +366,21 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @returns The `morris` function returns an array of `MapCallbackReturn<N>` values.
      */
     morris(callback?: MapCallback<N>, pattern?: DFSOrderPattern, beginRoot?: N | null): MapCallbackReturn<N>[];
+    /**
+     * Swap the data of two nodes in the binary tree.
+     * @param {N} srcNode - The source node to swap.
+     * @param {N} destNode - The destination node to swap.
+     * @returns {N} - The destination node after the swap.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
+    /**
+     * Time complexity is O(n)
+     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
+     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
+     * the tree's structure should be restored to its original state to maintain the tree's integrity.
+     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
+     */
+    protected _defaultCallbackByKey: MapCallback<N>;
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to

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

@@ -106,24 +106,22 @@ class BinaryTree {
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
+        this._loopType = types_1.IterationType.ITERATIVE;
         this._root = null;
         this._size = 0;
-        this._loopType = types_1.IterationType.ITERATIVE;
+        /**
+         * Time complexity is O(n)
+         * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
+         * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
+         * the tree's structure should be restored to its original state to maintain the tree's integrity.
+         * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
+         */
         this._defaultCallbackByKey = node => node.key;
         if (options !== undefined) {
             const { iterationType = types_1.IterationType.ITERATIVE } = options;
             this._loopType = iterationType;
         }
     }
-    /**
-     * Creates a new instance of BinaryTreeNode with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The key for the new node.
-     * @param {N['val']} val - The value for the new node.
-     * @returns {N} - The newly created BinaryTreeNode.
-     */
-    createNode(key, val) {
-        return new BinaryTreeNode(key, val);
-    }
     /**
      * Get the root node of the binary tree.
      */
@@ -150,21 +148,13 @@ class BinaryTree {
         this._loopType = v;
     }
     /**
-     * Swap the data of two nodes in the binary tree.
-     * @param {N} srcNode - The source node to swap.
-     * @param {N} destNode - The destination node to swap.
-     * @returns {N} - The destination node after the swap.
+     * Creates a new instance of BinaryTreeNode with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The key for the new node.
+     * @param {N['val']} val - The value for the new node.
+     * @returns {N} - The newly created BinaryTreeNode.
      */
-    _swap(srcNode, destNode) {
-        const { key, val } = destNode;
-        const tempNode = this.createNode(key, val);
-        if (tempNode) {
-            destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
-            srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
-        }
-        return destNode;
+    createNode(key, val) {
+        return new BinaryTreeNode(key, val);
     }
     /**
      * Clear the binary tree, removing all nodes.
@@ -834,7 +824,6 @@ class BinaryTree {
         }
         return ans;
     }
-    // --- start additional methods ---
     /**
      * The bfs function performs a breadth-first search traversal on a binary tree, executing a callback
      * function on each node.
@@ -899,13 +888,7 @@ class BinaryTree {
             return node;
         }
     }
-    /**
-     * Time complexity is O(n)
-     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-     * the tree's structure should be restored to its original state to maintain the tree's integrity.
-     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-     */
+    // --- start additional methods ---
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
      * algorithm and returns an array of values obtained by applying a callback function to each node.
@@ -1004,6 +987,23 @@ class BinaryTree {
         }
         return ans;
     }
+    /**
+     * Swap the data of two nodes in the binary tree.
+     * @param {N} srcNode - The source node to swap.
+     * @param {N} destNode - The destination node to swap.
+     * @returns {N} - The destination node after the swap.
+     */
+    _swap(srcNode, destNode) {
+        const { key, val } = destNode;
+        const tempNode = this.createNode(key, val);
+        if (tempNode) {
+            destNode.key = srcNode.key;
+            destNode.val = srcNode.val;
+            srcNode.key = tempNode.key;
+            srcNode.val = tempNode.val;
+        }
+        return destNode;
+    }
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to

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

@@ -2,8 +2,8 @@ import { BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../
 import { IBinaryTree } from '../../interfaces';
 import { BST, BSTNode } from './bst';
 export declare class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNodeNested<V>> extends BSTNode<V, FAMILY> {
-    private _color;
     constructor(key: BinaryTreeNodeKey, val?: V);
+    private _color;
     get color(): RBColor;
     set color(value: RBColor);
 }

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

@@ -10,6 +10,7 @@ import { BinaryTreeDeletedResult, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> {
+    count: number;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
@@ -21,7 +22,6 @@ export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
     constructor(key: BinaryTreeNodeKey, val?: V, count?: number);
-    count: number;
 }
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
@@ -46,14 +46,6 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
-    /**
-     * The function swaps the values of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-     * from `srcNode` will be swapped into.
-     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     */
-    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The `add` function adds a new node to a binary search tree, updating the count if the key already
      * exists, and balancing the tree if necessary.
@@ -114,6 +106,14 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * The function swaps the values of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from `srcNode` will be swapped into.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function sets the value of the "_count" property.
      * @param {number} v - number

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

@@ -49,29 +49,6 @@ class TreeMultiset extends avl_tree_1.AVLTree {
     createNode(key, val, count) {
         return new TreeMultisetNode(key, val, count);
     }
-    /**
-     * The function swaps the values of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-     * from `srcNode` will be swapped into.
-     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     */
-    _swap(srcNode, destNode) {
-        const { key, val, count, height } = destNode;
-        const tempNode = this.createNode(key, val, count);
-        if (tempNode) {
-            tempNode.height = height;
-            destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
-            destNode.count = srcNode.count;
-            destNode.height = srcNode.height;
-            srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
-            srcNode.count = tempNode.count;
-            srcNode.height = tempNode.height;
-        }
-        return destNode;
-    }
     /**
      * The `add` function adds a new node to a binary search tree, updating the count if the key already
      * exists, and balancing the tree if necessary.
@@ -340,6 +317,29 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         super.clear();
         this._setCount(0);
     }
+    /**
+     * The function swaps the values of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from `srcNode` will be swapped into.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    _swap(srcNode, destNode) {
+        const { key, val, count, height } = destNode;
+        const tempNode = this.createNode(key, val, count);
+        if (tempNode) {
+            tempNode.height = height;
+            destNode.key = srcNode.key;
+            destNode.val = srcNode.val;
+            destNode.count = srcNode.count;
+            destNode.height = srcNode.height;
+            srcNode.key = tempNode.key;
+            srcNode.val = tempNode.val;
+            srcNode.count = tempNode.count;
+            srcNode.height = tempNode.height;
+        }
+        return destNode;
+    }
     /**
      * The function sets the value of the "_count" property.
      * @param {number} v - number

package/dist/data-structures/hash/hash-map.d.ts

@@ -7,24 +7,6 @@ import { HashFunction } from '../../types';
  * @license MIT License
  */
 export declare class HashMap<K, V> {
-    get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
-    get table(): Array<Array<[K, V]>>;
-    set table(value: Array<Array<[K, V]>>);
-    get capacityMultiplier(): number;
-    set capacityMultiplier(value: number);
-    get loadFactor(): number;
-    set loadFactor(value: number);
-    get initialCapacity(): number;
-    set initialCapacity(value: number);
-    get size(): number;
-    set size(value: number);
-    private _initialCapacity;
-    private _loadFactor;
-    private _capacityMultiplier;
-    private _size;
-    private _table;
-    private _hashFn;
     /**
      * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
      * multiplier, size, table array, and hash function.
@@ -38,6 +20,31 @@ export declare class HashMap<K, V> {
      * default hash function converts the key to a string, calculates the sum of the
      */
     constructor(initialCapacity?: number, loadFactor?: number, hashFn?: HashFunction<K>);
+    private _initialCapacity;
+    get initialCapacity(): number;
+    set initialCapacity(value: number);
+    private _loadFactor;
+    get loadFactor(): number;
+    set loadFactor(value: number);
+    private _capacityMultiplier;
+    get capacityMultiplier(): number;
+    set capacityMultiplier(value: number);
+    private _size;
+    get size(): number;
+    set size(value: number);
+    private _table;
+    get table(): Array<Array<[K, V]>>;
+    set table(value: Array<Array<[K, V]>>);
+    private _hashFn;
+    get hashFn(): HashFunction<K>;
+    set hashFn(value: HashFunction<K>);
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    delete(key: K): void;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    clear(): void;
+    isEmpty(): boolean;
     private _hash;
     /**
      * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
@@ -46,11 +53,4 @@ export declare class HashMap<K, V> {
      * the number of buckets that the new table should have.
      */
     private resizeTable;
-    set(key: K, value: V): void;
-    get(key: K): V | undefined;
-    delete(key: K): void;
-    entries(): IterableIterator<[K, V]>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    clear(): void;
-    isEmpty(): boolean;
 }

package/dist/data-structures/hash/hash-map.js

@@ -9,42 +9,6 @@ exports.HashMap = void 0;
  * @license MIT License
  */
 class HashMap {
-    get hashFn() {
-        return this._hashFn;
-    }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
-    get table() {
-        return this._table;
-    }
-    set table(value) {
-        this._table = value;
-    }
-    get capacityMultiplier() {
-        return this._capacityMultiplier;
-    }
-    set capacityMultiplier(value) {
-        this._capacityMultiplier = value;
-    }
-    get loadFactor() {
-        return this._loadFactor;
-    }
-    set loadFactor(value) {
-        this._loadFactor = value;
-    }
-    get initialCapacity() {
-        return this._initialCapacity;
-    }
-    set initialCapacity(value) {
-        this._initialCapacity = value;
-    }
-    get size() {
-        return this._size;
-    }
-    set size(value) {
-        this._size = value;
-    }
     /**
      * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
      * multiplier, size, table array, and hash function.
@@ -74,30 +38,41 @@ class HashMap {
                     return hash % this.table.length;
                 });
     }
-    _hash(key) {
-        return this._hashFn(key);
+    get initialCapacity() {
+        return this._initialCapacity;
     }
-    /**
-     * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
-     * rehashing the key-value pairs from the old table into the new table.
-     * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
-     * the number of buckets that the new table should have.
-     */
-    resizeTable(newCapacity) {
-        const newTable = new Array(newCapacity);
-        for (const bucket of this._table) {
-            // Note that this is this._table
-            if (bucket) {
-                for (const [key, value] of bucket) {
-                    const newIndex = this._hash(key) % newCapacity;
-                    if (!newTable[newIndex]) {
-                        newTable[newIndex] = [];
-                    }
-                    newTable[newIndex].push([key, value]);
-                }
-            }
-        }
-        this._table = newTable; // Again, here is this._table
+    set initialCapacity(value) {
+        this._initialCapacity = value;
+    }
+    get loadFactor() {
+        return this._loadFactor;
+    }
+    set loadFactor(value) {
+        this._loadFactor = value;
+    }
+    get capacityMultiplier() {
+        return this._capacityMultiplier;
+    }
+    set capacityMultiplier(value) {
+        this._capacityMultiplier = value;
+    }
+    get size() {
+        return this._size;
+    }
+    set size(value) {
+        this._size = value;
+    }
+    get table() {
+        return this._table;
+    }
+    set table(value) {
+        this._table = value;
+    }
+    get hashFn() {
+        return this._hashFn;
+    }
+    set hashFn(value) {
+        this._hashFn = value;
     }
     set(key, value) {
         const loadFactor = this.size / this.table.length;
@@ -167,5 +142,30 @@ class HashMap {
     isEmpty() {
         return this.size === 0;
     }
+    _hash(key) {
+        return this._hashFn(key);
+    }
+    /**
+     * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
+     * rehashing the key-value pairs from the old table into the new table.
+     * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
+     * the number of buckets that the new table should have.
+     */
+    resizeTable(newCapacity) {
+        const newTable = new Array(newCapacity);
+        for (const bucket of this._table) {
+            // Note that this is this._table
+            if (bucket) {
+                for (const [key, value] of bucket) {
+                    const newIndex = this._hash(key) % newCapacity;
+                    if (!newTable[newIndex]) {
+                        newTable[newIndex] = [];
+                    }
+                    newTable[newIndex].push([key, value]);
+                }
+            }
+        }
+        this._table = newTable; // Again, here is this._table
+    }
 }
 exports.HashMap = HashMap;