stack-typed 1.46.2 → 1.46.5

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

@@ -5,99 +5,23 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, IterableWithSizeOrLength, IterateDirection } from '../../types';
-/**
- * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
- * these underlying structures have already dealt with dynamic expansion and hash collisions.
- * Therefore, there is no need for additional logic to handle these issues.
- */
-export declare class HashMapIterator<K, V> {
-    readonly hashMap: HashMap<K, V>;
-    readonly iterateDirection: IterateDirection;
-    protected _node: HashMapLinkedNode<K, V>;
-    protected readonly _sentinel: HashMapLinkedNode<K, V>;
-    /**
-     * This is a constructor function for a linked list iterator in a HashMap data structure.
-     * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
-     * represents a node in a linked list used in a hash map data structure. It contains a key-value pair
-     * and references to the previous and next nodes in the linked list.
-     * @param sentinel - The `sentinel` parameter is a reference to a special node in a linked list. It
-     * is used to mark the beginning or end of the list and is typically used in data structures like
-     * hash maps or linked lists to simplify operations and boundary checks.
-     * @param hashMap - A HashMap object that stores key-value pairs.
-     * @param {IterateDirection} iterateDirection - The `iterateDirection` parameter is an optional
-     * parameter that specifies the direction in which the iterator should iterate over the elements of
-     * the HashMap. It can take one of the following values:
-     * @returns The constructor does not return anything. It is used to initialize the properties and
-     * methods of the object being created.
-     */
-    constructor(node: HashMapLinkedNode<K, V>, sentinel: HashMapLinkedNode<K, V>, hashMap: HashMap<K, V>, iterateDirection?: IterateDirection);
-    /**
-     * The above function returns a Proxy object that allows access to the key and value of a node in a
-     * data structure.
-     * @returns The code is returning a Proxy object.
-     */
-    get current(): [K, V];
-    /**
-     * The function checks if a node is accessible.
-     * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
-     */
-    isAccessible(): boolean;
-    prev(): this;
-    next(): this;
-    clone(): HashMapIterator<K, V>;
-}
+import { HashMapLinkedNode, HashMapOptions } from '../../types';
 export declare class HashMap<K = any, V = any> {
-    readonly OBJ_KEY_INDEX: symbol;
-    protected _nodes: HashMapLinkedNode<K, V>[];
-    protected _orgMap: Record<string, HashMapLinkedNode<K, V>>;
-    protected _head: HashMapLinkedNode<K, V>;
-    protected _tail: HashMapLinkedNode<K, V>;
-    protected readonly _sentinel: HashMapLinkedNode<K, V>;
-    /**
-     * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
-     * @param {Iterable<[K, V]>} elements - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
-     * V]>`. It is an array of key-value pairs, where each pair is represented as an array `[K, V]`. The
-     * `K` represents the type of the key and `V` represents the
-     */
-    constructor(elements?: IterableWithSizeOrLength<[K, V]>);
+    protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
+    protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
+    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;
+    /**
+     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
+     * @param options - The `options` parameter is an object that contains the `elements` property. The
+     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
+     */
+    constructor(options?: HashMapOptions<K, V>);
     protected _size: number;
     get size(): number;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new iterator object for a HashMap.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get begin(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-     * end values.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get end(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-     * a HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseBegin(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-     * HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseEnd(): HashMapIterator<K, V>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -116,6 +40,15 @@ export declare class HashMap<K = any, V = any> {
      * data structure.
      */
     get last(): [K, V] | undefined;
+    /**
+     * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
+     */
+    begin(): Generator<(K | V | undefined)[], void, unknown>;
+    /**
+     * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+     * key and value.
+     */
+    reverseBegin(): Generator<(K | V | undefined)[], void, unknown>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -126,10 +59,9 @@ export declare class HashMap<K = any, V = any> {
      * type, but typically it is a string or symbol.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
      * value associated with the key being set in the data structure.
-     * @param {boolean} isObjectKey - A boolean flag indicating whether the key is an object key or not.
      * @returns the size of the data structure after the key-value pair has been set.
      */
-    set(key: K, value?: V, isObjectKey?: boolean): number;
+    set(key: K, value?: V): number;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -138,15 +70,12 @@ export declare class HashMap<K = any, V = any> {
      * key directly or by using an index stored in the key object.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
      * of any type, but typically it is a string or symbol.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that
-     * `key` is an object key. If `isObjectKey` is `false`, it means that `key`
      * @returns The value associated with the given key is being returned. If the key is an object key,
      * the value is retrieved from the `_nodes` array using the index stored in the `OBJ_KEY_INDEX`
-     * property of the key. If the key is a string key, the value is retrieved from the `_orgMap` object
+     * 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, isObjectKey?: boolean): V | undefined;
+    get(key: K): V | undefined;
     /**
      * Time Complexity: O(n), where n is the index.
      * Space Complexity: O(1)
@@ -159,20 +88,6 @@ export declare class HashMap<K = any, V = any> {
      * where `K` is the key and `V` is the value.
      */
     getAt(index: number): [K, V];
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `getIterator` returns a new instance of `HashMapIterator` based on the provided key
-     * and whether it is an object key or not.
-     * @param {K} key - The `key` parameter is the key used to retrieve the iterator from the HashMap. It
-     * can be of any type, depending on how the HashMap is implemented.
-     * @param {boolean} [isObjectKey] - The `isObjectKey` parameter is an optional boolean parameter that
-     * indicates whether the `key` parameter is an object key. If `isObjectKey` is `true`, it means that
-     * the `key` parameter is an object and needs to be handled differently. If `isObjectKey` is `false`
-     * @returns a new instance of the `HashMapIterator` class.
-     */
-    getIterator(key: K, isObjectKey?: boolean): HashMapIterator<K, V>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -180,13 +95,10 @@ export declare class HashMap<K = any, V = any> {
      * The `delete` function removes a key-value pair from a map-like data structure.
      * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
      * It can be of any type, but typically it is a string or an object.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that the
-     * `key` parameter is an object key. If `isObjectKey` is `false`, it means that the
      * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
      * was not found.
      */
-    delete(key: K, isObjectKey?: boolean): boolean;
+    delete(key: K): boolean;
     /**
      * Time Complexity: O(n), where n is the index.
      * Space Complexity: O(1)
@@ -223,6 +135,9 @@ export declare class HashMap<K = any, V = any> {
      * HashMap. It takes three arguments:
      */
     forEach(callback: (element: [K, V], index: number, hashMap: HashMap<K, V>) => void): void;
+    filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V>;
+    map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV>;
+    reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A;
     /**
      * Time Complexity: O(n), where n is the number of elements in the HashMap.
      * Space Complexity: O(1)
@@ -240,5 +155,5 @@ export declare class HashMap<K = any, V = any> {
      * represents a node in a linked list. It contains a key-value pair and references to the previous
      * and next nodes in the list.
      */
-    protected _deleteNode(node: HashMapLinkedNode<K, V>): void;
+    protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): void;
 }

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

@@ -7,178 +7,36 @@
  * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashMap = exports.HashMapIterator = void 0;
+exports.HashMap = void 0;
 const utils_1 = require("../../utils");
-/**
- * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
- * these underlying structures have already dealt with dynamic expansion and hash collisions.
- * Therefore, there is no need for additional logic to handle these issues.
- */
-class HashMapIterator {
-    /**
-     * This is a constructor function for a linked list iterator in a HashMap data structure.
-     * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
-     * represents a node in a linked list used in a hash map data structure. It contains a key-value pair
-     * and references to the previous and next nodes in the linked list.
-     * @param sentinel - The `sentinel` parameter is a reference to a special node in a linked list. It
-     * is used to mark the beginning or end of the list and is typically used in data structures like
-     * hash maps or linked lists to simplify operations and boundary checks.
-     * @param hashMap - A HashMap object that stores key-value pairs.
-     * @param {IterateDirection} iterateDirection - The `iterateDirection` parameter is an optional
-     * parameter that specifies the direction in which the iterator should iterate over the elements of
-     * the HashMap. It can take one of the following values:
-     * @returns The constructor does not return anything. It is used to initialize the properties and
-     * methods of the object being created.
-     */
-    constructor(node, sentinel, hashMap, iterateDirection = 0 /* IterateDirection.DEFAULT */) {
-        this._node = node;
-        this._sentinel = sentinel;
-        this.iterateDirection = iterateDirection;
-        if (this.iterateDirection === 0 /* IterateDirection.DEFAULT */) {
-            this.prev = function () {
-                if (this._node.prev === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.prev;
-                return this;
-            };
-            this.next = function () {
-                if (this._node === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.next;
-                return this;
-            };
-        }
-        else {
-            this.prev = function () {
-                if (this._node.next === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.next;
-                return this;
-            };
-            this.next = function () {
-                if (this._node === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.prev;
-                return this;
-            };
-        }
-        this.hashMap = hashMap;
-    }
-    /**
-     * The above function returns a Proxy object that allows access to the key and value of a node in a
-     * data structure.
-     * @returns The code is returning a Proxy object.
-     */
-    get current() {
-        if (this._node === this._sentinel) {
-            (0, utils_1.throwRangeError)();
-        }
-        return new Proxy([], {
-            get: (target, prop) => {
-                if (prop === '0')
-                    return this._node.key;
-                else if (prop === '1')
-                    return this._node.value;
-                target[0] = this._node.key;
-                target[1] = this._node.value;
-                return target[prop];
-            },
-            set: (_, prop, newValue) => {
-                if (prop !== '1') {
-                    throw new TypeError(`prop should be string '1'`);
-                }
-                this._node.value = newValue;
-                return true;
-            }
-        });
-    }
-    /**
-     * The function checks if a node is accessible.
-     * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
-     */
-    isAccessible() {
-        return this._node !== this._sentinel;
-    }
-    prev() {
-        return this;
-    }
-    next() {
-        return this;
-    }
-    clone() {
-        return new HashMapIterator(this._node, this._sentinel, this.hashMap, this.iterateDirection);
-    }
-}
-exports.HashMapIterator = HashMapIterator;
 class HashMap {
     /**
-     * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
-     * @param {Iterable<[K, V]>} elements - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
-     * V]>`. It is an array of key-value pairs, where each pair is represented as an array `[K, V]`. The
-     * `K` represents the type of the key and `V` represents the
+     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
+     * @param options - The `options` parameter is an object that contains the `elements` property. The
+     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
      */
-    constructor(elements = []) {
-        this.OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
-        this._nodes = [];
-        this._orgMap = {};
+    constructor(options = {
+        elements: [],
+        hashFn: (key) => String(key),
+        objHashFn: (key) => key
+    }) {
+        this._noObjMap = {};
+        this._objMap = new WeakMap();
         this._size = 0;
-        Object.setPrototypeOf(this._orgMap, null);
         this._sentinel = {};
         this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-        for (const el of elements) {
-            this.set(el[0], el[1]);
+        const { elements, hashFn, objHashFn } = options;
+        this._hashFn = hashFn;
+        this._objHashFn = objHashFn;
+        if (elements) {
+            for (const el of elements) {
+                this.set(el[0], el[1]);
+            }
         }
     }
     get size() {
         return this._size;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new iterator object for a HashMap.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get begin() {
-        return new HashMapIterator(this._head, this._sentinel, this);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-     * end values.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get end() {
-        return new HashMapIterator(this._sentinel, this._sentinel, this);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-     * a HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseBegin() {
-        return new HashMapIterator(this._tail, this._sentinel, this, 1 /* IterateDirection.REVERSE */);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-     * HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseEnd() {
-        return new HashMapIterator(this._sentinel, this._sentinel, this, 1 /* IterateDirection.REVERSE */);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -205,6 +63,27 @@ class HashMap {
             return;
         return [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;
+        while (node !== this._sentinel) {
+            yield [node.key, node.value];
+            node = node.next;
+        }
+    }
+    /**
+     * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+     * key and value.
+     */
+    *reverseBegin() {
+        let node = this._tail;
+        while (node !== this._sentinel) {
+            yield [node.key, node.value];
+            node = node.prev;
+        }
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -215,52 +94,51 @@ class HashMap {
      * type, but typically it is a string or symbol.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
      * value associated with the key being set in the data structure.
-     * @param {boolean} isObjectKey - A boolean flag indicating whether the key is an object key or not.
      * @returns the size of the data structure after the key-value pair has been set.
      */
-    set(key, value, isObjectKey = (0, utils_1.isObjOrFunc)(key)) {
-        let newTail;
-        if (isObjectKey) {
-            const index = key[this.OBJ_KEY_INDEX];
-            if (index !== undefined) {
-                this._nodes[index].value = value;
-                return this._size;
+    set(key, value) {
+        let node;
+        if ((0, utils_1.isWeakKey)(key)) {
+            const hash = this._objHashFn(key);
+            node = this._objMap.get(hash);
+            if (node) {
+                // If the node already exists, update its value
+                node.value = value;
+            }
+            else {
+                // Create new node
+                node = { key: hash, value, prev: this._tail, next: this._sentinel };
+                // Add new nodes to _objMap and linked list
+                this._objMap.set(hash, node);
             }
-            Object.defineProperty(key, this.OBJ_KEY_INDEX, {
-                value: this._nodes.length,
-                configurable: true
-            });
-            newTail = {
-                key: key,
-                value: value,
-                prev: this._tail,
-                next: this._sentinel
-            };
-            this._nodes.push(newTail);
         }
         else {
-            const node = this._orgMap[key];
+            const hash = this._hashFn(key);
+            // Non-object keys are handled in the same way as the original implementation
+            node = this._noObjMap[hash];
             if (node) {
                 node.value = value;
-                return this._size;
             }
-            this._orgMap[key] = newTail = {
-                key: key,
-                value: value,
-                prev: this._tail,
-                next: this._sentinel
-            };
+            else {
+                this._noObjMap[hash] = node = {
+                    key,
+                    value,
+                    prev: this._tail,
+                    next: this._sentinel
+                };
+            }
         }
         if (this._size === 0) {
-            this._head = newTail;
-            this._sentinel.next = newTail;
+            this._head = node;
+            this._sentinel.next = node;
         }
         else {
-            this._tail.next = newTail;
+            this._tail.next = node;
         }
-        this._tail = newTail;
-        this._sentinel.prev = newTail;
-        return ++this._size;
+        this._tail = node;
+        this._sentinel.prev = node;
+        this._size++;
+        return this._size;
     }
     /**
      * Time Complexity: O(1)
@@ -270,21 +148,22 @@ class HashMap {
      * key directly or by using an index stored in the key object.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
      * of any type, but typically it is a string or symbol.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that
-     * `key` is an object key. If `isObjectKey` is `false`, it means that `key`
      * @returns The value associated with the given key is being returned. If the key is an object key,
      * the value is retrieved from the `_nodes` array using the index stored in the `OBJ_KEY_INDEX`
-     * property of the key. If the key is a string key, the value is retrieved from the `_orgMap` object
+     * 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, isObjectKey = (0, utils_1.isObjOrFunc)(key)) {
-        if (isObjectKey) {
-            const index = key[this.OBJ_KEY_INDEX];
-            return index !== undefined ? this._nodes[index].value : undefined;
+    get(key) {
+        if ((0, utils_1.isWeakKey)(key)) {
+            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];
+            return node ? node.value : undefined;
         }
-        const node = this._orgMap[key];
-        return node ? node.value : undefined;
     }
     /**
      * Time Complexity: O(n), where n is the index.
@@ -305,35 +184,6 @@ class HashMap {
         }
         return [node.key, node.value];
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `getIterator` returns a new instance of `HashMapIterator` based on the provided key
-     * and whether it is an object key or not.
-     * @param {K} key - The `key` parameter is the key used to retrieve the iterator from the HashMap. It
-     * can be of any type, depending on how the HashMap is implemented.
-     * @param {boolean} [isObjectKey] - The `isObjectKey` parameter is an optional boolean parameter that
-     * indicates whether the `key` parameter is an object key. If `isObjectKey` is `true`, it means that
-     * the `key` parameter is an object and needs to be handled differently. If `isObjectKey` is `false`
-     * @returns a new instance of the `HashMapIterator` class.
-     */
-    getIterator(key, isObjectKey) {
-        let node;
-        if (isObjectKey) {
-            const index = key[this.OBJ_KEY_INDEX];
-            if (index === undefined) {
-                node = this._sentinel;
-            }
-            else {
-                node = this._nodes[index];
-            }
-        }
-        else {
-            node = this._orgMap[key] || this._sentinel;
-        }
-        return new HashMapIterator(node, this._sentinel, this);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -341,28 +191,32 @@ class HashMap {
      * The `delete` function removes a key-value pair from a map-like data structure.
      * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
      * It can be of any type, but typically it is a string or an object.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that the
-     * `key` parameter is an object key. If `isObjectKey` is `false`, it means that the
      * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
      * was not found.
      */
-    delete(key, isObjectKey = (0, utils_1.isObjOrFunc)(key)) {
+    delete(key) {
         let node;
-        if (isObjectKey) {
-            const index = key[this.OBJ_KEY_INDEX];
-            if (index === undefined)
-                return false;
-            delete key[this.OBJ_KEY_INDEX];
-            node = this._nodes[index];
-            delete this._nodes[index];
+        if ((0, utils_1.isWeakKey)(key)) {
+            const hash = this._objHashFn(key);
+            // Get nodes from WeakMap
+            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);
         }
         else {
-            node = this._orgMap[key];
-            if (node === undefined)
-                return false;
-            delete this._orgMap[key];
+            const hash = this._hashFn(key);
+            // Get nodes from noObjMap
+            node = this._noObjMap[hash];
+            if (!node) {
+                return false; // If the node does not exist, return false
+            }
+            // Remove nodes from orgMap
+            delete this._noObjMap[hash];
         }
+        // Remove node from doubly linked list
         this._deleteNode(node);
         return true;
     }
@@ -402,13 +256,7 @@ class HashMap {
      * The `clear` function clears all the elements in a data structure and resets its properties.
      */
     clear() {
-        // const OBJ_KEY_INDEX = this.OBJ_KEY_INDEX;
-        // this._nodes.forEach(el => {
-        //   delete (<Record<symbol, number>><unknown>el.key)[OBJ_KEY_INDEX];
-        // });
-        this._nodes = [];
-        this._orgMap = {};
-        Object.setPrototypeOf(this._orgMap, null);
+        this._noObjMap = {};
         this._size = 0;
         this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
     }
@@ -429,6 +277,30 @@ class HashMap {
             node = node.next;
         }
     }
+    filter(predicate) {
+        const filteredMap = new HashMap();
+        for (const [key, value] of this) {
+            if (predicate([key, value], this)) {
+                filteredMap.set(key, value);
+            }
+        }
+        return filteredMap;
+    }
+    map(callback) {
+        const mappedMap = new HashMap();
+        for (const [key, value] of this) {
+            const newValue = callback([key, value], this);
+            mappedMap.set(key, newValue);
+        }
+        return mappedMap;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        for (const element of this) {
+            accumulator = callback(accumulator, element, this);
+        }
+        return accumulator;
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the HashMap.
      * Space Complexity: O(1)