min-heap-typed 1.46.3 → 1.46.6

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

@@ -441,11 +441,12 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     [Symbol.iterator](node?: N | null | undefined): Generator<BTNKey, void, undefined>;
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
+     * @param {N | null | undefined} beginRoot - The `root` parameter is of type `BTNKey | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
      */
     print(beginRoot?: BTNKey | N | null | undefined): void;
+    protected _displayAux(node: N | null | undefined): [string[], number, number, number];
     protected _defaultOneParamCallback: (node: N) => number;
     /**
      * Swap the data of two nodes in the binary tree.

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

@@ -1447,7 +1447,7 @@ class BinaryTree {
     }
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
+     * @param {N | null | undefined} beginRoot - The `root` parameter is of type `BTNKey | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
      */
@@ -1456,57 +1456,40 @@ class BinaryTree {
         if (!beginRoot)
             return;
         const display = (root) => {
-            const [lines, , ,] = _displayAux(root);
+            const [lines, , ,] = this._displayAux(root);
             for (const line of lines) {
                 console.log(line);
             }
         };
-        const _displayAux = (node) => {
-            if (!this.isRealNode(node)) {
-                return [[], 0, 0, 0];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
-                const line = `${node.key}`;
-                const width = line.length;
-                const height = 1;
-                const middle = Math.floor(width / 2);
-                return [[line], width, height, middle];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.right)) {
-                const [lines, n, p, x] = _displayAux(node.left);
-                const s = `${node.key}`;
-                const u = s.length;
-                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
-                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
-                const shifted_lines = lines.map(line => line + ' '.repeat(u));
-                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.left)) {
-                const [lines, n, p, u] = _displayAux(node.right);
-                const s = `${node.key}`;
-                const x = s.length;
-                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
-                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
-                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
-                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
-            }
-            const [left, n, p, x] = _displayAux(node.left);
-            const [right, m, q, y] = _displayAux(node.right);
-            const s = `${node.key}`;
-            const u = s.length;
-            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
-            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
-            if (p < q) {
-                left.push(...new Array(q - p).fill(' '.repeat(n)));
-            }
-            else if (q < p) {
-                right.push(...new Array(p - q).fill(' '.repeat(m)));
-            }
-            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
-            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
-        };
         display(beginRoot);
     }
+    _displayAux(node) {
+        if (!node) {
+            return [['─'], 1, 0, 0];
+        }
+        const line = node.key.toString();
+        const width = line.length;
+        if (!node.left && !node.right) {
+            return [[line], width, 1, Math.floor(width / 2)];
+        }
+        const [leftLines, leftWidth, leftHeight, leftMiddle] = node.left ? this._displayAux(node.left) : [[''], 0, 0, 0];
+        const [rightLines, rightWidth, rightHeight, rightMiddle] = node.right ? this._displayAux(node.right) : [[''], 0, 0, 0];
+        const firstLine = ' '.repeat(Math.max(0, leftMiddle + 1))
+            + '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1))
+            + line
+            + '_'.repeat(Math.max(0, rightMiddle))
+            + ' '.repeat(Math.max(0, rightWidth - rightMiddle));
+        const secondLine = (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth))
+            + ' '.repeat(width)
+            + (rightHeight > 0 ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1) : ' '.repeat(rightWidth));
+        const mergedLines = [firstLine, secondLine];
+        for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
+            const leftLine = i < leftHeight ? leftLines[i] : ' '.repeat(leftWidth);
+            const rightLine = i < rightHeight ? rightLines[i] : ' '.repeat(rightWidth);
+            mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
+        }
+        return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
+    }
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.

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

@@ -81,11 +81,16 @@ class RedBlackTree extends bst_1.BST {
         let x = this.root;
         while (x !== this.NIL) {
             y = x;
-            if (x && node.key < x.key) {
-                x = x.left;
-            }
-            else {
-                x = x === null || x === void 0 ? void 0 : x.right;
+            if (x) {
+                if (node.key < x.key) {
+                    x = x.left;
+                }
+                else if (node.key > x.key) {
+                    x = x === null || x === void 0 ? void 0 : x.right;
+                }
+                else {
+                    return;
+                }
             }
         }
         node.parent = y;

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

@@ -5,21 +5,21 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, IterableWithSizeOrLength } from '../../types';
+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>;
+    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 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?: IterableWithSizeOrLength<[K, V]>);
+    constructor(options?: HashMapOptions<K, V>);
     protected _size: number;
     get size(): number;
     /**
@@ -43,12 +43,12 @@ export declare class HashMap<K = any, V = any> {
     /**
      * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
      */
-    begin(): Generator<(K | V)[], void, unknown>;
+    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)[], void, unknown>;
+    reverseBegin(): Generator<(K | V | undefined)[], void, unknown>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -59,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)
@@ -71,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)
@@ -99,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)
@@ -142,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)
@@ -159,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

@@ -11,21 +11,27 @@ exports.HashMap = void 0;
 const utils_1 = require("../../utils");
 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() {
@@ -88,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)
@@ -143,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.
@@ -185,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;
     }
@@ -246,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;
     }
@@ -273,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)

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

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

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

@@ -15,8 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./hash-table"), exports);
-__exportStar(require("./coordinate-map"), exports);
-__exportStar(require("./coordinate-set"), exports);
-__exportStar(require("./tree-map"), exports);
-__exportStar(require("./tree-set"), exports);
 __exportStar(require("./hash-map"), exports);

package/dist/index.d.ts

@@ -7,4 +7,4 @@
  */
 export * from './data-structures/heap/min-heap';
 export * from './types/data-structures/heap/min-heap';
-export * from './types/helpers';
+export * from './types/common';

package/dist/index.js

@@ -24,4 +24,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // export { MinHeap } from 'data-structure-typed';
 __exportStar(require("./data-structures/heap/min-heap"), exports);
 __exportStar(require("./types/data-structures/heap/min-heap"), exports);
-__exportStar(require("./types/helpers"), exports);
+__exportStar(require("./types/common"), exports);

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

@@ -4,3 +4,8 @@ export type HashMapLinkedNode<K, V> = {
     next: HashMapLinkedNode<K, V>;
     prev: HashMapLinkedNode<K, V>;
 };
+export type HashMapOptions<K, V> = {
+    elements: Iterable<[K, V]>;
+    hashFn: (key: K) => string;
+    objHashFn: (key: K) => object;
+};

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

@@ -1,7 +1,3 @@
-export * from './coordinate-map';
-export * from './coordinate-set';
 export * from './hash-map';
 export * from './hash-table';
-export * from './tree-map';
-export * from './tree-set';
 export type HashFunction<K> = (key: K) => number;

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

@@ -14,9 +14,5 @@ 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("./coordinate-map"), exports);
-__exportStar(require("./coordinate-set"), exports);
 __exportStar(require("./hash-map"), exports);
 __exportStar(require("./hash-table"), exports);
-__exportStar(require("./tree-map"), exports);
-__exportStar(require("./tree-set"), exports);

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
 export * from './data-structures';
-export * from './helpers';
+export * from './common';
 export * from './utils';

package/dist/types/index.js

@@ -15,5 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./data-structures"), exports);
-__exportStar(require("./helpers"), exports);
+__exportStar(require("./common"), exports);
 __exportStar(require("./utils"), exports);

package/dist/utils/utils.d.ts

@@ -20,5 +20,5 @@ export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Paramet
 export declare const getMSB: (value: number) => number;
 export declare const rangeCheck: (index: number, min: number, max: number, message?: string) => void;
 export declare const throwRangeError: (message?: string) => void;
-export declare const isObjOrFunc: (input: unknown) => input is Record<string, unknown> | ((...args: any[]) => any);
+export declare const isWeakKey: (input: unknown) => input is object;
 export declare const calcMinUnitsRequired: (totalQuantity: number, unitSize: number) => number;

package/dist/utils/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcMinUnitsRequired = exports.isObjOrFunc = exports.throwRangeError = exports.rangeCheck = exports.getMSB = exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
+exports.calcMinUnitsRequired = exports.isWeakKey = exports.throwRangeError = exports.rangeCheck = exports.getMSB = exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
 const uuidV4 = function () {
     return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
         const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
@@ -80,10 +80,10 @@ const throwRangeError = (message = 'The value is off-limits.') => {
     throw new RangeError(message);
 };
 exports.throwRangeError = throwRangeError;
-const isObjOrFunc = (input) => {
+const isWeakKey = (input) => {
     const inputType = typeof input;
     return (inputType === 'object' && input !== null) || inputType === 'function';
 };
-exports.isObjOrFunc = isObjOrFunc;
+exports.isWeakKey = isWeakKey;
 const calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
 exports.calcMinUnitsRequired = calcMinUnitsRequired;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.46.3",
+  "version": "1.46.6",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -132,6 +132,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.46.3"
+    "data-structure-typed": "^1.46.6"
   }
 }