min-heap-typed 1.50.1 → 1.50.3

package/src/data-structures/hash/hash-map.ts

@@ -22,9 +22,6 @@ import { isWeakKey, rangeCheck } from '../../utils';
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
-  protected _store: { [key: string]: HashMapStoreItem<K, V> } = {};
-  protected _objMap: Map<object, V> = new Map();
-
   /**
    * The constructor function initializes a HashMap object with an optional initial collection and
    * options.
@@ -32,7 +29,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * `T`. It is an optional parameter and its default value is an empty array `[]`.
    * @param [options] - The `options` parameter is an optional object that can contain two properties:
    */
-  constructor(rawCollection: Iterable<R> = [], options?: HashMapOptions<K, V, R>) {
+  constructor(rawCollection: Iterable<R | [K, V]> = [], options?: HashMapOptions<K, V, R>) {
     super();
     if (options) {
       const { hashFn, toEntryFn } = options;
@@ -48,6 +45,28 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     }
   }
 
+  protected _store: { [key: string]: HashMapStoreItem<K, V> } = {};
+
+  /**
+   * The function returns the store object, which is a dictionary of HashMapStoreItem objects.
+   * @returns The store property is being returned. It is a dictionary-like object with string keys and
+   * values of type HashMapStoreItem<K, V>.
+   */
+  get store(): { [p: string]: HashMapStoreItem<K, V> } {
+    return this._store;
+  }
+
+  protected _objMap: Map<object, V> = new Map();
+
+  /**
+   * The function returns the object map.
+   * @returns The `objMap` property is being returned, which is a `Map` object with keys of type
+   * `object` and values of type `V`.
+   */
+  get objMap(): Map<object, V> {
+    return this._objMap;
+  }
+
   protected _toEntryFn: (rawElement: R) => [K, V] = (rawElement: R) => {
     if (this.isEntry(rawElement)) {
       // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
@@ -59,24 +78,58 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     }
   };
 
+  /**
+   * The function returns the value of the _toEntryFn property.
+   * @returns The function being returned is `this._toEntryFn`.
+   */
   get toEntryFn() {
     return this._toEntryFn;
   }
 
   protected _size = 0;
 
+  /**
+   * The function returns the size of an object.
+   * @returns The size of the object, which is a number.
+   */
   get size(): number {
     return this._size;
   }
 
+  protected _hashFn: (key: K) => string = (key: K) => String(key);
+
+  /**
+   * The hasFn function is a function that takes in an item and returns a boolean
+   * indicating whether the item is contained within the hash table.
+   *
+   * @return The hash function
+   */
+  get hashFn() {
+    return this._hashFn;
+  }
+
+  /**
+   * The function checks if a given element is an array with exactly two elements.
+   * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
+   * data type.
+   * @returns a boolean value.
+   */
   isEntry(rawElement: any): rawElement is [K, V] {
     return Array.isArray(rawElement) && rawElement.length === 2;
   }
 
+  /**
+   * The function checks if the size of an object is equal to zero and returns a boolean value.
+   * @returns A boolean value indicating whether the size of the object is 0 or not.
+   */
   isEmpty(): boolean {
     return this.size === 0;
   }
 
+  /**
+   * The clear() function resets the state of an object by clearing its internal store, object map, and
+   * size.
+   */
   clear() {
     this._store = {};
     this._objMap.clear();
@@ -94,13 +147,13 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    */
   set(key: K, value: V): boolean {
     if (this._isObjKey(key)) {
-      if (!this._objMap.has(key)) {
+      if (!this.objMap.has(key)) {
         this._size++;
       }
-      this._objMap.set(key, value);
+      this.objMap.set(key, value);
     } else {
       const strKey = this._getNoObjKey(key);
-      if (this._store[strKey] === undefined) {
+      if (this.store[strKey] === undefined) {
         this._size++;
       }
       this._store[strKey] = { key, value };
@@ -115,10 +168,18 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * `T`.
    * @returns The `setMany` function is returning an array of booleans.
    */
-  setMany(rawCollection: Iterable<R>): boolean[] {
+  setMany(rawCollection: Iterable<R | [K, V]>): boolean[] {
     const results: boolean[] = [];
     for (const rawEle of rawCollection) {
-      const [key, value] = this.toEntryFn(rawEle);
+      let key, value;
+      if (this.isEntry(rawEle)) {
+        key = rawEle[0];
+        value = rawEle[1];
+      } else {
+        const item = this.toEntryFn(rawEle);
+        key = item[0];
+        value = item[1];
+      }
       results.push(this.set(key, value));
     }
     return results;
@@ -132,9 +193,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * @returns The method `get(key: K)` returns a value of type `V` if the key exists in the `_objMap`
    * or `_store`, otherwise it returns `undefined`.
    */
-  get(key: K): V | undefined {
+  override get(key: K): V | undefined {
     if (this._isObjKey(key)) {
-      return this._objMap.get(key);
+      return this.objMap.get(key);
     } else {
       const strKey = this._getNoObjKey(key);
       return this._store[strKey]?.value;
@@ -147,12 +208,12 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * @param {K} key - The parameter "key" is of type K, which means it can be any type.
    * @returns The `has` method is returning a boolean value.
    */
-  has(key: K): boolean {
+  override has(key: K): boolean {
     if (this._isObjKey(key)) {
-      return this._objMap.has(key);
+      return this.objMap.has(key);
     } else {
       const strKey = this._getNoObjKey(key);
-      return strKey in this._store;
+      return strKey in this.store;
     }
   }
 
@@ -165,15 +226,15 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    */
   delete(key: K): boolean {
     if (this._isObjKey(key)) {
-      if (this._objMap.has(key)) {
+      if (this.objMap.has(key)) {
         this._size--;
       }
 
-      return this._objMap.delete(key);
+      return this.objMap.delete(key);
     } else {
       const strKey = this._getNoObjKey(key);
-      if (strKey in this._store) {
-        delete this._store[strKey];
+      if (strKey in this.store) {
+        delete this.store[strKey];
         this._size--;
         return true;
       }
@@ -181,6 +242,22 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     }
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * The clone function creates a new HashMap with the same key-value pairs as
+   * this one. The clone function is useful for creating a copy of an existing
+   * HashMap, and then modifying that copy without affecting the original.
+   *
+   * @return A new hashmap with the same values as this one
+   */
+  clone(): HashMap<K, V, R> {
+    return new HashMap<K, V, R>(this, { hashFn: this.hashFn, toEntryFn: this.toEntryFn });
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -209,11 +286,6 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     return resultMap;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -241,6 +313,14 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     return filteredMap;
   }
 
+  /**
+   * The put function sets a value in a data structure using a specified key.
+   * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
+   * to the function.
+   * @param {V} value - The value parameter represents the value that you want to associate with the
+   * specified key in the data structure.
+   * @returns The method is returning a boolean value.
+   */
   put(key: K, value: V): boolean {
     return this.set(key, value);
   }
@@ -250,27 +330,37 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * object map.
    */
   protected* _getIterator(): IterableIterator<[K, V]> {
-    for (const node of Object.values(this._store)) {
+    for (const node of Object.values(this.store)) {
       yield [node.key, node.value] as [K, V];
     }
-    for (const node of this._objMap) {
+    for (const node of this.objMap) {
       yield node as [K, V];
     }
   }
 
-  protected _hashFn: (key: K) => string = (key: K) => String(key);
-
+  /**
+   * The function checks if a given key is an object or a function.
+   * @param {any} key - The parameter "key" can be of any type.
+   * @returns a boolean value.
+   */
   protected _isObjKey(key: any): key is object | ((...args: any[]) => any) {
     const keyType = typeof key;
     return (keyType === 'object' || keyType === 'function') && key !== null;
   }
 
+  /**
+   * The function `_getNoObjKey` takes a key and returns a string representation of the key, handling
+   * different types of keys.
+   * @param {K} key - The `key` parameter is of type `K`, which represents the type of the key being
+   * passed to the `_getNoObjKey` function.
+   * @returns a string value.
+   */
   protected _getNoObjKey(key: K): string {
     const keyType = typeof key;
 
     let strKey: string;
     if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
-      strKey = this._hashFn(key);
+      strKey = this.hashFn(key);
     } else {
       if (keyType === 'number') {
         // TODO numeric key should has its own hash
@@ -288,37 +378,138 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
  * 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 class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
-  protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
-  protected _objMap = new WeakMap<object, HashMapLinkedNode<K, V | undefined>>();
-  protected _head: HashMapLinkedNode<K, V | undefined>;
-  protected _tail: HashMapLinkedNode<K, V | undefined>;
+export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
   protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
 
-  constructor(entries?: Iterable<[K, V]>, options?: LinkedHashMapOptions<K>) {
+  /**
+   * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
+   * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements. It is
+   * used to initialize the HashMapLinked instance with key-value pairs. Each element in the
+   * `rawCollection` is converted to a key-value pair using the `toEntryFn` function (if provided) and
+   * then added to the HashMap
+   * @param [options] - The `options` parameter is an optional object that can contain the following
+   * properties:
+   */
+  constructor(rawCollection: Iterable<R> = [], options?: LinkedHashMapOptions<K, V, R>) {
     super();
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
 
     if (options) {
-      const { hashFn, objHashFn } = options;
+      const { hashFn, objHashFn, toEntryFn } = options;
       if (hashFn) this._hashFn = hashFn;
       if (objHashFn) this._objHashFn = objHashFn;
+
+      if (toEntryFn) {
+        this._toEntryFn = toEntryFn;
+      }
     }
 
-    if (entries) {
-      for (const el of entries) {
-        this.set(el[0], el[1]);
+    if (rawCollection) {
+      for (const el of rawCollection) {
+        const [key, value] = this.toEntryFn(el);
+        this.set(key, value);
       }
     }
   }
 
+  protected _hashFn: (key: K) => string = (key: K) => String(key);
+
+  /**
+   * The function returns the hash function used for generating a hash value for a given key.
+   * @returns The hash function that takes a key of type K and returns a string.
+   */
+  get hashFn(): (key: K) => string {
+    return this._hashFn;
+  }
+
+  protected _objHashFn: (key: K) => object = (key: K) => <object>key;
+
+  /**
+   * The function returns the object hash function.
+   * @returns The function `objHashFn` is being returned.
+   */
+  get objHashFn(): (key: K) => object {
+    return this._objHashFn;
+  }
+
+  protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
+
+  /**
+   * The function returns a record of HashMapLinkedNode objects with string keys.
+   * @returns The method is returning a Record object, which is a TypeScript type that represents an
+   * object with string keys and values that are HashMapLinkedNode objects with keys of type K and
+   * values of type V or undefined.
+   */
+  get noObjMap(): Record<string, HashMapLinkedNode<K, V | undefined>> {
+    return this._noObjMap;
+  }
+
+  protected _objMap = new WeakMap<object, HashMapLinkedNode<K, V | undefined>>();
+
+  /**
+   * The function returns the WeakMap object used to map objects to HashMapLinkedNode instances.
+   * @returns The `objMap` property is being returned.
+   */
+  get objMap(): WeakMap<object, HashMapLinkedNode<K, V | undefined>> {
+    return this._objMap;
+  }
+
+  protected _head: HashMapLinkedNode<K, V | undefined>;
+
+  /**
+   * The function returns the head node of a HashMapLinkedNode.
+   * @returns The method `getHead()` is returning a `HashMapLinkedNode` object with key type `K` and
+   * value type `V | undefined`.
+   */
+  get head(): HashMapLinkedNode<K, V | undefined> {
+    return this._head;
+  }
+
+  protected _tail: HashMapLinkedNode<K, V | undefined>;
+
+  /**
+   * The function returns the tail node of a HashMapLinkedNode.
+   * @returns The `_tail` property of type `HashMapLinkedNode<K, V | undefined>` is being returned.
+   */
+  get tail(): HashMapLinkedNode<K, V | undefined> {
+    return this._tail;
+  }
+
+  protected _toEntryFn: (rawElement: R) => [K, V] = (rawElement: R) => {
+    if (this.isEntry(rawElement)) {
+      // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
+      return rawElement;
+    } else {
+      throw new Error(
+        "If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
+      );
+    }
+  };
+
+  /**
+   * The function returns the value of the _toEntryFn property.
+   * @returns The function being returned is `this._toEntryFn`.
+   */
+  get toEntryFn() {
+    return this._toEntryFn;
+  }
+
   protected _size = 0;
 
+  /**
+   * The function returns the size of an object.
+   * @returns The size of the object.
+   */
   get size() {
     return this._size;
   }
 
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -329,9 +520,14 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    */
   get first() {
     if (this._size === 0) return;
-    return <[K, V]>[this._head.key, this._head.value];
+    return <[K, V]>[this.head.key, this.head.value];
   }
 
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -342,14 +538,14 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    */
   get last() {
     if (this._size === 0) return;
-    return <[K, V]>[this._tail.key, this._tail.value];
+    return <[K, V]>[this.tail.key, this.tail.value];
   }
 
   /**
    * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
    */
   * begin() {
-    let node = this._head;
+    let node = this.head;
     while (node !== this._sentinel) {
       yield [node.key, node.value];
       node = node.next;
@@ -361,13 +557,18 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * key and value.
    */
   * reverseBegin() {
-    let node = this._tail;
+    let node = this.tail;
     while (node !== this._sentinel) {
       yield [node.key, node.value];
       node = node.prev;
     }
   }
 
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -385,23 +586,23 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     const isNewKey = !this.has(key); // Check if the key is new
 
     if (isWeakKey(key)) {
-      const hash = this._objHashFn(key);
-      node = this._objMap.get(hash);
+      const hash = this.objHashFn(key);
+      node = this.objMap.get(hash);
 
       if (!node && isNewKey) {
         // Create new node
-        node = { key: <K>hash, value, prev: this._tail, next: this._sentinel };
-        this._objMap.set(hash, node);
+        node = { key: <K>hash, value, prev: this.tail, next: this._sentinel };
+        this.objMap.set(hash, node);
       } else if (node) {
         // Update the value of an existing node
         node.value = value;
       }
     } else {
-      const hash = this._hashFn(key);
-      node = this._noObjMap[hash];
+      const hash = this.hashFn(key);
+      node = this.noObjMap[hash];
 
       if (!node && isNewKey) {
-        this._noObjMap[hash] = node = { key, value, prev: this._tail, next: this._sentinel };
+        this.noObjMap[hash] = node = { key, value, prev: this.tail, next: this._sentinel };
       } else if (node) {
         // Update the value of an existing node
         node.value = value;
@@ -414,8 +615,8 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
         this._head = node;
         this._sentinel.next = node;
       } else {
-        this._tail.next = node;
-        node.prev = this._tail; // Make sure that the prev of the new node points to the current tail node
+        this.tail.next = node;
+        node.prev = this.tail; // Make sure that the prev of the new node points to the current tail node
       }
       this._tail = node;
       this._sentinel.prev = node;
@@ -425,25 +626,44 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     return true;
   }
 
-  has(key: K): boolean {
-    if (isWeakKey(key)) {
-      const hash = this._objHashFn(key);
-      return this._objMap.has(hash);
-    } else {
-      const hash = this._hashFn(key);
-      return hash in this._noObjMap;
-    }
-  }
-
-  setMany(entries: Iterable<[K, V]>): boolean[] {
+  /**
+   * The function `setMany` takes an iterable collection, converts each element into a key-value pair
+   * using a provided function, and sets each key-value pair in the current object, returning an array
+   * of booleans indicating the success of each set operation.
+   * @param rawCollection - The rawCollection parameter is an iterable collection of elements of type
+   * R.
+   * @returns The `setMany` function returns an array of booleans.
+   */
+  setMany(rawCollection: Iterable<R>): boolean[] {
     const results: boolean[] = [];
-    for (const entry of entries) {
-      const [key, value] = entry;
+    for (const rawEle of rawCollection) {
+      const [key, value] = this.toEntryFn(rawEle);
       results.push(this.set(key, value));
     }
     return results;
   }
 
+  /**
+   * The function checks if a given key exists in a map, using different logic depending on whether the
+   * key is a weak key or not.
+   * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
+   * @returns The method `has` is returning a boolean value.
+   */
+  override has(key: K): boolean {
+    if (isWeakKey(key)) {
+      const hash = this.objHashFn(key);
+      return this.objMap.has(hash);
+    } else {
+      const hash = this.hashFn(key);
+      return hash in this.noObjMap;
+    }
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -457,32 +677,37 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * property of the key. If the key is a string key, the value is retrieved from the `_noObjMap` object
    * using the key itself. If the key is not found, `undefined` is
    */
-  get(key: K): V | undefined {
+  override get(key: K): V | undefined {
     if (isWeakKey(key)) {
-      const hash = this._objHashFn(key);
-      const node = this._objMap.get(hash);
+      const hash = this.objHashFn(key);
+      const node = this.objMap.get(hash);
       return node ? node.value : undefined;
     } else {
-      const hash = this._hashFn(key);
-      const node = this._noObjMap[hash];
+      const hash = this.hashFn(key);
+      const node = this.noObjMap[hash];
       return node ? node.value : undefined;
     }
   }
 
   /**
-   * Time Complexity: O(n), where n is the index.
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   * /
+
+   /**
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
-   * The function `getAt` retrieves the key-value pair at a specified index in a linked list.
+   * The function `at` retrieves the key-value pair at a specified index in a linked list.
    * @param {number} index - The index parameter is a number that represents the position of the
    * element we want to retrieve from the data structure.
-   * @returns The method `getAt(index: number)` is returning an array containing the key-value pair at
+   * @returns The method `at(index: number)` is returning an array containing the key-value pair at
    * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
    * where `K` is the key and `V` is the value.
    */
-  getAt(index: number): V | undefined {
+  at(index: number): V | undefined {
     rangeCheck(index, 0, this._size - 1);
-    let node = this._head;
+    let node = this.head;
     while (index--) {
       node = node.next;
     }
@@ -490,6 +715,11 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   * /
+
+   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
@@ -503,27 +733,27 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     let node;
 
     if (isWeakKey(key)) {
-      const hash = this._objHashFn(key);
+      const hash = this.objHashFn(key);
       // Get nodes from WeakMap
-      node = this._objMap.get(hash);
+      node = this.objMap.get(hash);
 
       if (!node) {
         return false; // If the node does not exist, return false
       }
 
       // Remove nodes from WeakMap
-      this._objMap.delete(hash);
+      this.objMap.delete(hash);
     } else {
-      const hash = this._hashFn(key);
+      const hash = this.hashFn(key);
       // Get nodes from noObjMap
-      node = this._noObjMap[hash];
+      node = this.noObjMap[hash];
 
       if (!node) {
         return false; // If the node does not exist, return false
       }
 
       // Remove nodes from orgMap
-      delete this._noObjMap[hash];
+      delete this.noObjMap[hash];
     }
 
     // Remove node from doubly linked list
@@ -532,7 +762,12 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the index.
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   * /
+
+   /**
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
    * The `deleteAt` function deletes a node at a specified index in a linked list.
@@ -542,7 +777,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    */
   deleteAt(index: number): boolean {
     rangeCheck(index, 0, this._size - 1);
-    let node = this._head;
+    let node = this.head;
     while (index--) {
       node = node.next;
     }
@@ -550,6 +785,11 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   * /
+
+   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
@@ -562,6 +802,21 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   }
 
   /**
+   * The function checks if a given element is an array with exactly two elements.
+   * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
+   * data type.
+   * @returns a boolean value.
+   */
+  isEntry(rawElement: any): rawElement is [K, V] {
+    return Array.isArray(rawElement) && rawElement.length === 2;
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   * /
+
+   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
@@ -573,8 +828,22 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `clone` function creates a new instance of a `LinkedHashMap` with the same key-value pairs as
+   * the original.
+   * @returns The `clone()` method is returning a new instance of `LinkedHashMap<K, V>` that is a clone
+   * of the original `LinkedHashMap` object.
+   */
   clone(): LinkedHashMap<K, V> {
-    const cloned = new LinkedHashMap<K, V>([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
+    const cloned = new LinkedHashMap<K, V>([], { hashFn: this.hashFn, objHashFn: this.objHashFn });
     for (const entry of this) {
       const [key, value] = entry;
       cloned.set(key, value);
@@ -583,6 +852,11 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   }
 
   /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   * /
+
+   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
@@ -610,6 +884,11 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   }
 
   /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   * /
+
+   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
@@ -638,37 +917,51 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   }
 
   /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The put function sets a value in a data structure using a specified key.
+   * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
+   * to the function.
+   * @param {V} value - The value parameter represents the value that you want to associate with the
+   * specified key in the data structure.
+   * @returns The method is returning a boolean value.
+   */
   put(key: K, value: V): boolean {
     return this.set(key, value);
   }
 
   /**
    * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
-  protected _hashFn: (key: K) => string = (key: K) => String(key);
-
-  protected _objHashFn: (key: K) => object = (key: K) => <object>key;
+   * Space Complexity: O(1)
+   * where n is the number of entries in the LinkedHashMap.
+   * /
 
-  /**
-   * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
+   /**
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
+   * where n is the number of entries in the LinkedHashMap.
    *
    * The above function is an iterator that yields key-value pairs from a linked list.
    */
   protected* _getIterator() {
-    let node = this._head;
+    let node = this.head;
     while (node !== this._sentinel) {
       yield [node.key, node.value] as [K, V];
       node = node.next;
     }
   }
 
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -684,11 +977,11 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     prev.next = next;
     next.prev = prev;
 
-    if (node === this._head) {
+    if (node === this.head) {
       this._head = next;
     }
 
-    if (node === this._tail) {
+    if (node === this.tail) {
       this._tail = prev;
     }