linked-list-typed 1.49.6 → 1.49.7

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

@@ -23,15 +23,15 @@ export declare class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N
  */
 export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>, TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>> extends BST<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
     /**
-     * The constructor function initializes an AVLTree object with optional nodes and options.
-     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * The constructor function initializes an AVLTree object with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
      * objects. It represents a collection of nodes that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
      * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
      * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
      */
-    constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<AVLTreeOptions<K>>);
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: AVLTreeOptions<K>);
     /**
      * The function creates a new AVL tree node with the specified key and value.
      * @param {K} key - The key parameter is the key value that will be associated with

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

@@ -27,18 +27,18 @@ exports.AVLTreeNode = AVLTreeNode;
  */
 class AVLTree extends bst_1.BST {
     /**
-     * The constructor function initializes an AVLTree object with optional nodes and options.
-     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * The constructor function initializes an AVLTree object with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
      * objects. It represents a collection of nodes that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
      * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
      * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
      */
-    constructor(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
-        if (nodes)
-            super.addMany(nodes);
+        if (keysOrNodesOrEntries)
+            super.addMany(keysOrNodesOrEntries);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.

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

@@ -41,15 +41,15 @@ export declare class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K
 export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, N, TREE> {
     iterationType: IterationType;
     /**
-     * The constructor function initializes a binary tree object with optional nodes and options.
-     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
      * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<BinaryTreeOptions<K>>);
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: BinaryTreeOptions<K>);
     protected _extractor: (key: K) => number;
     get extractor(): (key: K) => number;
     protected _root?: N | null;

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

@@ -68,31 +68,29 @@ exports.BinaryTreeNode = BinaryTreeNode;
  */
 class BinaryTree extends base_1.IterableEntryBase {
     /**
-     * The constructor function initializes a binary tree object with optional nodes and options.
-     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
      * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super();
         this.iterationType = types_1.IterationType.ITERATIVE;
         this._extractor = (key) => Number(key);
         this._defaultOneParamCallback = (node) => (node ? node.key : undefined);
         if (options) {
             const { iterationType, extractor } = options;
-            if (iterationType) {
+            if (iterationType)
                 this.iterationType = iterationType;
-            }
-            if (extractor) {
+            if (extractor)
                 this._extractor = extractor;
-            }
         }
         this._size = 0;
-        if (nodes)
-            this.addMany(nodes);
+        if (keysOrNodesOrEntries)
+            this.addMany(keysOrNodesOrEntries);
     }
     get extractor() {
         return this._extractor;

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

@@ -45,13 +45,13 @@ export declare class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTN
 export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, N, TREE> = BST<K, V, N, BSTNested<K, V, N>>> extends BinaryTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
-     * the tree with optional nodes and options.
-     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
+     * the tree with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
-    constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<BSTOptions<K>>);
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: BSTOptions<K>);
     protected _root?: N;
     get root(): N | undefined;
     protected _variant: BSTVariant;

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

@@ -57,24 +57,23 @@ exports.BSTNode = BSTNode;
 class BST extends binary_tree_1.BinaryTree {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
-     * the tree with optional nodes and options.
-     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
+     * the tree with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
-    constructor(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
         this._variant = types_1.BSTVariant.STANDARD;
         if (options) {
             const { variant } = options;
-            if (variant) {
+            if (variant)
                 this._variant = variant;
-            }
         }
         this._root = undefined;
-        if (nodes)
-            this.addMany(nodes);
+        if (keysOrNodesOrEntries)
+            this.addMany(keysOrNodesOrEntries);
     }
     get root() {
         return this._root;

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

@@ -24,7 +24,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
-     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
      * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * nodes to the
@@ -32,7 +32,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: RBTreeOptions<K>);
     protected _root: N;
     get root(): N;
     protected _size: number;

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

@@ -28,7 +28,7 @@ class RedBlackTree extends bst_1.BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
-     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
      * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * nodes to the
@@ -36,13 +36,13 @@ class RedBlackTree extends bst_1.BST {
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
         this.Sentinel = new RedBlackTreeNode(NaN);
         this._size = 0;
         this._root = this.Sentinel;
-        if (nodes)
-            super.addMany(nodes);
+        if (keysOrNodesOrEntries)
+            super.addMany(keysOrNodesOrEntries);
     }
     get root() {
         return this._root;

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

@@ -27,7 +27,7 @@ export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNo
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>> extends AVLTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
-    constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: TreeMultimapOptions<K>);
     private _count;
     get count(): number;
     /**

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

@@ -24,11 +24,11 @@ exports.TreeMultimapNode = TreeMultimapNode;
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 class TreeMultimap extends avl_tree_1.AVLTree {
-    constructor(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
         this._count = 0;
-        if (nodes)
-            this.addMany(nodes);
+        if (keysOrNodesOrEntries)
+            this.addMany(keysOrNodesOrEntries);
     }
     // TODO the _count is not accurate after nodes count modified
     get count() {

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

@@ -5,13 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem, LinkedHashMapOptions } from '../../types';
 import { IterableEntryBase } from '../base';
 /**
  * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
- * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete elements based on a key.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries based on a key.
  * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
- * 4. Unordered Collection: HashMap does not guarantee the order of elements, and the order may change over time.
+ * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _store: {
@@ -19,16 +19,14 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     };
     protected _objMap: Map<object, V>;
     /**
-     * The constructor function initializes a new instance of a class with optional elements and options.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * The constructor function initializes a new instance of a class with optional entries and options.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
      * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
      * key-value pairs.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the constructor. In this case, it has one property:
      */
-    constructor(elements?: Iterable<[K, V]>, options?: {
-        hashFn: (key: K) => string;
-    });
+    constructor(entries?: Iterable<[K, V]>, options?: HashMapOptions<K>);
     protected _size: number;
     get size(): number;
     isEmpty(): boolean;
@@ -45,10 +43,10 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     set(key: K, value: V): boolean;
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two elements: the key and the value.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two entries: the key and the value.
      */
-    setMany(elements: Iterable<[K, V]>): boolean[];
+    setMany(entries: Iterable<[K, V]>): boolean[];
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
@@ -113,7 +111,6 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      * from the original `HashMap` that pass the provided `predicate` function.
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): HashMap<K, V>;
-    print(): void;
     put(key: K, value: V): boolean;
     /**
      * The function returns an iterator that yields key-value pairs from both an object store and an
@@ -125,8 +122,8 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _getNoObjKey(key: K): string;
 }
 /**
- * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which elements are inserted. Therefore, when you traverse it, elements will be returned in the order they were inserted into the map.
- * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of elements through the linked list.
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which entries are inserted. Therefore, when you traverse it, entries will be returned in the order they were inserted into the map.
+ * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of entries through the linked list.
  * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
  */
 export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
@@ -135,9 +132,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
     protected _head: HashMapLinkedNode<K, V | undefined>;
     protected _tail: HashMapLinkedNode<K, V | undefined>;
     protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
-    protected _hashFn: (key: K) => string;
-    protected _objHashFn: (key: K) => object;
-    constructor(elements?: Iterable<[K, V]>, options?: HashMapOptions<K>);
+    constructor(entries?: Iterable<[K, V]>, options?: LinkedHashMapOptions<K>);
     protected _size: number;
     get size(): number;
     /**
@@ -242,14 +237,10 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function clears all the elements in a data structure and resets its properties.
+     * The `clear` function clears all the entries in a data structure and resets its properties.
      */
     clear(): void;
     clone(): LinkedHashMap<K, V>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -266,10 +257,6 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * `LinkedHashMap` object that satisfy the given predicate function.
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -288,9 +275,19 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * function.
      */
     map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     put(key: K, value: V): boolean;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    protected _hashFn: (key: K) => string;
+    protected _objHashFn: (key: K) => object;
+    /**
+     * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.

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

@@ -5,20 +5,20 @@ const base_1 = require("../base");
 const utils_1 = require("../../utils");
 /**
  * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
- * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete elements based on a key.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries based on a key.
  * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
- * 4. Unordered Collection: HashMap does not guarantee the order of elements, and the order may change over time.
+ * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 class HashMap extends base_1.IterableEntryBase {
     /**
-     * The constructor function initializes a new instance of a class with optional elements and options.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * The constructor function initializes a new instance of a class with optional entries and options.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
      * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
      * key-value pairs.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the constructor. In this case, it has one property:
      */
-    constructor(elements = [], options) {
+    constructor(entries = [], options) {
         super();
         this._store = {};
         this._objMap = new Map();
@@ -30,8 +30,8 @@ class HashMap extends base_1.IterableEntryBase {
                 this._hashFn = hashFn;
             }
         }
-        if (elements) {
-            this.setMany(elements);
+        if (entries) {
+            this.setMany(entries);
         }
     }
     get size() {
@@ -72,12 +72,12 @@ class HashMap extends base_1.IterableEntryBase {
     }
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two elements: the key and the value.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two entries: the key and the value.
      */
-    setMany(elements) {
+    setMany(entries) {
         const results = [];
-        for (const [key, value] of elements)
+        for (const [key, value] of entries)
             results.push(this.set(key, value));
         return results;
     }
@@ -194,9 +194,6 @@ class HashMap extends base_1.IterableEntryBase {
         }
         return filteredMap;
     }
-    print() {
-        console.log([...this.entries()]);
-    }
     put(key, value) {
         return this.set(key, value);
     }
@@ -236,26 +233,33 @@ class HashMap extends base_1.IterableEntryBase {
 }
 exports.HashMap = HashMap;
 /**
- * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which elements are inserted. Therefore, when you traverse it, elements will be returned in the order they were inserted into the map.
- * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of elements through the linked list.
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which entries are inserted. Therefore, when you traverse it, entries will be returned in the order they were inserted into the map.
+ * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of entries through the linked list.
  * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
  */
 class LinkedHashMap extends base_1.IterableEntryBase {
-    constructor(elements, options = {
-        hashFn: (key) => String(key),
-        objHashFn: (key) => key
-    }) {
+    constructor(entries, options) {
         super();
         this._noObjMap = {};
         this._objMap = new WeakMap();
         this._size = 0;
+        /**
+         * Time Complexity: O(n)
+         * Space Complexity: O(n)
+         */
+        this._hashFn = (key) => String(key);
+        this._objHashFn = (key) => key;
         this._sentinel = {};
         this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-        const { hashFn, objHashFn } = options;
-        this._hashFn = hashFn;
-        this._objHashFn = objHashFn;
-        if (elements) {
-            for (const el of elements) {
+        if (options) {
+            const { hashFn, objHashFn } = options;
+            if (hashFn)
+                this._hashFn = hashFn;
+            if (objHashFn)
+                this._objHashFn = objHashFn;
+        }
+        if (entries) {
+            for (const el of entries) {
                 this.set(el[0], el[1]);
             }
         }
@@ -495,7 +499,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function clears all the elements in a data structure and resets its properties.
+     * The `clear` function clears all the entries in a data structure and resets its properties.
      */
     clear() {
         this._noObjMap = {};
@@ -510,10 +514,6 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
         return cloned;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -540,10 +540,6 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
         return filteredMap;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -571,11 +567,15 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
         return mappedMap;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     put(key, value) {
         return this.set(key, value);
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
+     * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.

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

@@ -1,2 +1 @@
-export * from './hash-table';
 export * from './hash-map';

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

@@ -14,5 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./hash-table"), exports);
 __exportStar(require("./hash-map"), exports);

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

@@ -19,8 +19,9 @@ import { IterableElementBase } from '../base';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 export declare class Heap<E = any> extends IterableElementBase<E> {
-    options: HeapOptions<E>;
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
+    protected _comparator: (a: E, b: E) => number;
+    get comparator(): (a: E, b: E) => number;
     protected _elements: E[];
     get elements(): E[];
     /**

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

@@ -21,10 +21,9 @@ const base_1 = require("../base");
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 class Heap extends base_1.IterableElementBase {
-    constructor(elements, options) {
+    constructor(elements = [], options) {
         super();
-        this._elements = [];
-        const defaultComparator = (a, b) => {
+        this._comparator = (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');
             }
@@ -32,13 +31,11 @@ class Heap extends base_1.IterableElementBase {
                 return a - b;
             }
         };
+        this._elements = [];
         if (options) {
-            this.options = options;
-        }
-        else {
-            this.options = {
-                comparator: defaultComparator
-            };
+            const { comparator } = options;
+            if (comparator)
+                this._comparator = comparator;
         }
         if (elements) {
             for (const el of elements) {
@@ -47,6 +44,9 @@ class Heap extends base_1.IterableElementBase {
             // this.fix();
         }
     }
+    get comparator() {
+        return this._comparator;
+    }
     get elements() {
         return this._elements;
     }
@@ -256,7 +256,7 @@ class Heap extends base_1.IterableElementBase {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-        const clonedHeap = new Heap([], this.options);
+        const clonedHeap = new Heap([], { comparator: this.comparator });
         clonedHeap._elements = [...this.elements];
         return clonedHeap;
     }
@@ -382,7 +382,7 @@ class Heap extends base_1.IterableElementBase {
         while (index > 0) {
             const parent = (index - 1) >> 1;
             const parentItem = this.elements[parent];
-            if (this.options.comparator(parentItem, element) <= 0)
+            if (this.comparator(parentItem, element) <= 0)
                 break;
             this.elements[index] = parentItem;
             index = parent;
@@ -404,11 +404,11 @@ class Heap extends base_1.IterableElementBase {
             let left = (index << 1) | 1;
             const right = left + 1;
             let minItem = this.elements[left];
-            if (right < this.elements.length && this.options.comparator(minItem, this.elements[right]) > 0) {
+            if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
                 left = right;
                 minItem = this.elements[right];
             }
-            if (this.options.comparator(minItem, element) >= 0)
+            if (this.comparator(minItem, element) >= 0)
                 break;
             this.elements[index] = minItem;
             index = left;

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

@@ -13,7 +13,7 @@ const heap_1 = require("./heap");
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 class MaxHeap extends heap_1.Heap {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');

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

@@ -13,7 +13,7 @@ const heap_1 = require("./heap");
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 class MinHeap extends heap_1.Heap {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');

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

@@ -25,7 +25,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and size.
      */
-    constructor(elements) {
+    constructor(elements = []) {
         super();
         this._head = undefined;
         this._tail = undefined;