data-structure-typed 1.51.8 → 1.52.0

package/src/types/data-structures/binary-tree/bst.ts

@@ -1,12 +1,11 @@
 import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
-import { Comparator } from "../../common";
-import { Comparable } from "../../utils";
+import { Comparator } from '../../common';
 
-export type BSTNodeNested<K extends Comparable, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type BSTNested<K extends Comparable, V, N extends BSTNode<K, V, N>> = BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type BSTOptions<K> = BinaryTreeOptions & {
+export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
   comparator?: Comparator<K>
 }

package/src/types/data-structures/binary-tree/rb-tree.ts

@@ -1,11 +1,10 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import type { BSTOptions } from "./bst";
-import { Comparable } from "../../utils";
 
 export type RBTNColor = 'RED' | 'BLACK';
 
-export type RedBlackTreeNodeNested<K extends Comparable, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type RedBlackTreeNested<K extends Comparable, V, N extends RedBlackTreeNode<K, V, N>> = RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type RedBlackTreeNested<K, V, R, NODE extends RedBlackTreeNode<K, V, NODE>> = RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type RBTreeOptions<K> = BSTOptions<K> & {};
+export type RBTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

package/src/types/data-structures/binary-tree/tree-multi-map.ts

@@ -1,9 +1,8 @@
 import { TreeMultiMap, TreeMultiMapNode } from '../../../data-structures';
 import type { RBTreeOptions } from './rb-tree';
-import { Comparable } from "../../utils";
 
-export type TreeMultiMapNodeNested<K extends Comparable, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type TreeMultiMapNested<K extends Comparable, V, N extends TreeMultiMapNode<K, V, N>> = TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type TreeMultiMapNested<K, V, R, NODE extends TreeMultiMapNode<K, V, NODE>> = TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type TreeMultiMapOptions<K> = RBTreeOptions<K> & {}
+export type TreeMultiMapOptions<K, V, R> = RBTreeOptions<K, V, R> & {}

package/src/types/data-structures/heap/heap.ts

@@ -1,3 +1,6 @@
 import { Comparator } from '../../common';
+import { IterableElementBaseOptions } from '../base';
 
-export type HeapOptions<T> = { comparator?: Comparator<T> };
+export type HeapOptions<E, R> = IterableElementBaseOptions<E, R> & {
+  comparator?: Comparator<E>;
+};

package/src/types/data-structures/linked-list/doubly-linked-list.ts

@@ -1 +1,3 @@
-export {};
+import { IterableElementBaseOptions } from '../base';
+
+export type DoublyLinkedListOptions<E, R> = IterableElementBaseOptions<E, R> & {};

package/src/types/data-structures/linked-list/singly-linked-list.ts

@@ -1 +1,3 @@
-export {};
+import { IterableElementBaseOptions } from '../base';
+
+export type SinglyLinkedListOptions<E, R> = IterableElementBaseOptions<E, R> & {};

package/src/types/data-structures/priority-queue/priority-queue.ts

@@ -1,3 +1,3 @@
 import { HeapOptions } from '../heap';
 
-export type PriorityQueueOptions<T> = HeapOptions<T> & {};
+export type PriorityQueueOptions<E, R> = HeapOptions<E, R> & {};

package/src/types/data-structures/queue/deque.ts

@@ -1 +1,3 @@
-export type DequeOptions = { bucketSize?: number };
+import { IterableElementBaseOptions } from '../base';
+
+export type DequeOptions<E, R> = { bucketSize?: number } & IterableElementBaseOptions<E, R>;

package/src/types/data-structures/queue/queue.ts

@@ -1 +1,3 @@
-export {};
+import { IterableElementBaseOptions } from '../base';
+
+export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {};

package/src/types/data-structures/stack/stack.ts

@@ -1 +1,3 @@
-export {};
+import { IterableElementBaseOptions } from '../base';
+
+export type StackOptions<E, R> = IterableElementBaseOptions<E, R> & {};

package/src/types/data-structures/trie/trie.ts

@@ -1 +1,3 @@
-export type TrieOptions = { caseSensitive?: boolean };
+import { IterableElementBaseOptions } from '../base';
+
+export type TrieOptions<R> = { caseSensitive?: boolean } & IterableElementBaseOptions<string, R>;

package/src/utils/utils.ts

@@ -108,7 +108,7 @@ export const roundFixed = (num: number, digit: number = 10) => {
 
 export function isComparable(key: any): key is Comparable {
   const keyType = typeof key;
-  if (keyType === 'number') return isNaN(key);
+  if (keyType === 'number') return !isNaN(key);
   if (keyType === 'string') return true;
   if (keyType === 'bigint') return true;
   if (keyType === 'boolean') return true;
@@ -117,8 +117,8 @@ export function isComparable(key: any): key is Comparable {
   if (keyType === 'function') return isComparable(key());
   if (keyType === 'object') {
     if (key === null) return true;
-    if (typeof key.valueOf === 'function') return isComparable(key.valueOf());
-    if (typeof key.toString === 'function') return isComparable(key.toString());
+    // if (typeof key.valueOf === 'function') return isComparable(key.valueOf());   // This will keep recursing because every object has a valueOf method.
+    // if (typeof key.toString === 'function') return isComparable(key.toString()); // This will also keep recursing because every string type has a toString method.
     return false;
   }
 

package/test/integration/avl-tree.test.ts

@@ -20,7 +20,7 @@ describe('AVL Tree Test', () => {
       [10, 10],
       [5, 5]
     ];
-    const tree = new AVLTree();
+    const tree = new AVLTree<number, number>();
 
     for (const i of arr) tree.add(i);
 
@@ -44,7 +44,7 @@ describe('AVL Tree Test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.

package/test/integration/bst.test.ts

@@ -2,7 +2,7 @@ import { BST, BSTNode } from 'bst-typed';
 
 describe('Individual package BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const bst = new BST();
+    const bst = new BST<number>();
     expect(bst).toBeInstanceOf(BST);
     bst.add([11, 11]);
     bst.add([3, 3]);
@@ -38,7 +38,7 @@ describe('Individual package BST operations test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -235,7 +235,7 @@ describe('Individual package BST operations test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);

package/test/integration/index.html

@@ -11,6 +11,20 @@
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.44.0/dist/umd/data-structure-typed.min.js'></script>-->
 
   <script src='https://unpkg.com/js-sdsl@4.4.2/dist/umd/js-sdsl.js'></script>
+  <script>
+    const logPerf = function (label = 'function running cost', fn, args, thisArg) {
+      const start = performance.now();
+      let result;
+      if (thisArg) {
+        if (args && args.length > 0) result = fn.apply(thisArg, args);
+        else result = fn.apply(thisArg);
+      } else {
+        if (args && args.length > 0) result = fn(...args);
+        else result = fn();
+      }
+      console.log(`${(performance.now() - start).toFixed(2)} ms, ${label}, ${result}`);
+    }
+  </script>
 </head>
 <body>
 <div id='app'>
@@ -26,19 +40,19 @@
     const { Queue } = dataStructureTyped;
     const queue = new Queue();
     const n = 1000000;
-    const startEn = performance.now();
-    for (let i = 0; i < n; i++) {
-      queue.push(i);
-    }
-    console.log((performance.now() - startEn).toFixed(2), `Queue ${n.toLocaleString()} enqueue `);
-    let last = 0;
-    const startTime = performance.now();
+    logPerf(`Queue ${n.toLocaleString()} enqueue`, () => {
+      for (let i = 0; i < n; i++) {
+        queue.push(i);
+      }
+    })
 
-    for (let i = 0; i < n; i++) {
-      last = queue.shift();
-    }
+    let last = 0;
 
-    console.log((performance.now() - startTime).toFixed(2), `Queue ${n.toLocaleString()} dequeue `);
+    logPerf(`Queue ${n.toLocaleString()} dequeue `, () => {
+      for (let i = 0; i < n; i++) {
+        last = queue.shift();
+      }
+    })
 
   } catch (e) {
     console.error(e);

package/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts

@@ -689,3 +689,71 @@ describe('AVLTreeMultiMap iterative methods test', () => {
     expect([...values]).toEqual(['a', 'b', 'c']);
   });
 });
+
+describe('AVLTree toEntryFn', () => {
+  it('should toEntryFn 1', () => {
+    const tree = new AVLTreeMultiMap<number, number, { obj: { id: number } }>([], {
+      toEntryFn: ele => [ele.obj.id, ele.obj.id]
+    });
+    tree.add({ obj: { id: 1 } });
+    tree.add({ obj: { id: 2 } });
+    tree.add({ obj: { id: 3 } });
+    tree.add({ obj: { id: 4 } });
+    tree.add({ obj: { id: 5 } });
+
+    const expected = [1, 2, 3, 4, 5];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+
+  it('should toEntryFn 2', () => {
+    const tree = new AVLTreeMultiMap<number, number, { obj: { id: number } }>(
+      [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
+      {
+        toEntryFn: ele => [ele.obj.id, ele.obj.id]
+      }
+    );
+
+    const expected = [1, 2, 3, 4, 5];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+
+  it('should toEntryFn throw error', () => {
+    expect(
+      () =>
+        new AVLTreeMultiMap<{ obj: { id: number } }, number>([
+          { obj: { id: 1 } },
+          { obj: { id: 2 } },
+          { obj: { id: 3 } },
+          { obj: { id: 4 } },
+          { obj: { id: 5 } }
+        ])
+    ).toThrowError(
+      `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+    );
+  });
+
+  it('should toEntryFn 3', () => {
+    const tree = new AVLTreeMultiMap<{ obj: { id: number } }, number>(
+      [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
+      { comparator: (a, b) => a.obj.id - b.obj.id }
+    );
+
+    const expected = [
+      { obj: { id: 1 } },
+      { obj: { id: 2 } },
+      { obj: { id: 3 } },
+      { obj: { id: 4 } },
+      { obj: { id: 5 } }
+    ];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+});

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -403,6 +403,62 @@ describe('BinaryTree Morris Traversal', () => {
   });
 });
 
+describe('BinaryTree toEntryFn', () => {
+  it('should toEntryFn 1', () => {
+    const tree = new BinaryTree<number, number, { obj: { id: number } }>([], {
+      toEntryFn: ele => [ele.obj.id, ele.obj.id]
+    });
+    tree.add({ obj: { id: 1 } });
+    tree.add({ obj: { id: 2 } });
+    tree.add({ obj: { id: 3 } });
+    tree.add({ obj: { id: 4 } });
+    tree.add({ obj: { id: 5 } });
+
+    const expected = [4, 2, 5, 1, 3];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+
+  it('should toEntryFn 2', () => {
+    const tree = new BinaryTree<number, number, { obj: { id: number } }>(
+      [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
+      {
+        toEntryFn: ele => [ele.obj.id, ele.obj.id]
+      }
+    );
+
+    const expected = [4, 2, 5, 1, 3];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+
+  it('should toEntryFn 3', () => {
+    const tree = new BinaryTree<{ obj: { id: number } }, number>([
+      { obj: { id: 1 } },
+      { obj: { id: 2 } },
+      { obj: { id: 3 } },
+      { obj: { id: 4 } },
+      { obj: { id: 5 } }
+    ]);
+
+    const expected = [
+      { obj: { id: 4 } },
+      { obj: { id: 2 } },
+      { obj: { id: 5 } },
+      { obj: { id: 1 } },
+      { obj: { id: 3 } }
+    ];
+
+    expect(tree.morris(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
+  });
+});
+
 describe('BinaryTree traversals', () => {
   const tree = new BinaryTree<number>();
 

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -132,11 +132,11 @@ class MyDirectedGraph<
   VO extends MyVertex<V> = MyVertex<V>,
   EO extends MyEdge<E> = MyEdge<E>
 > extends DirectedGraph<V, E, VO, EO> {
-  createVertex(key: VertexKey, value: V): VO {
+  override createVertex(key: VertexKey, value: V): VO {
     return new MyVertex(key, value) as VO;
   }
 
-  createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
+  override createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
     return new MyEdge(src, dest, weight ?? 1, value) as EO;
   }
 

package/test/unit/data-structures/heap/heap.test.ts

@@ -87,6 +87,86 @@ describe('Heap Operation Test', () => {
       maxI++;
     }
   });
+
+  it('should object heap map & filter', function () {
+    const minHeap = new MinHeap<{ a: string; key: number }>(
+      [
+        { key: 1, a: 'a1' },
+        { key: 6, a: 'a6' },
+        { key: 5, a: 'a5' },
+        { key: 3, a: 'a3' },
+        { key: 2, a: 'a2' },
+        { key: 4, a: 'a4' },
+        { key: 0, a: 'a0' }
+      ],
+      { comparator: (a, b) => a.key - b.key }
+    );
+
+    const mappedMinHeap = minHeap.map(
+      item => item.key,
+      (a, b) => a - b
+    );
+    expect(mappedMinHeap.peek()).toBe(0);
+    expect(mappedMinHeap.sort()).toEqual([0, 1, 2, 3, 4, 5, 6]);
+
+    const mappedToElementFnMinHeap = minHeap.map<string, { id: string }>(
+      item => item.key.toString(),
+      (a, b) => Number(a) - Number(b),
+      rawElement => rawElement.id
+    );
+    expect(mappedToElementFnMinHeap.peek()).toBe('0');
+    expect(mappedToElementFnMinHeap.sort()).toEqual(['0', '1', '2', '3', '4', '5', '6']);
+
+    const filteredHeap = minHeap.filter(item => item.key > 3);
+    expect(filteredHeap.peek()).toEqual({ a: 'a4', key: 4 });
+    expect(filteredHeap.sort()).toEqual([
+      { a: 'a4', key: 4 },
+      { a: 'a5', key: 5 },
+      { a: 'a6', key: 6 }
+    ]);
+  });
+
+  it('should object heap', () => {
+    const heap = new Heap<{ rawItem: { id: number } }>(
+      [
+        { rawItem: { id: 4 } },
+        { rawItem: { id: 8 } },
+        { rawItem: { id: 6 } },
+        { rawItem: { id: 7 } },
+        { rawItem: { id: 1 } },
+        { rawItem: { id: 3 } },
+        { rawItem: { id: 5 } }
+      ],
+      { comparator: (a, b) => a.rawItem.id - b.rawItem.id }
+    );
+
+    expect([...heap.sort()]).toEqual([
+      { rawItem: { id: 1 } },
+      { rawItem: { id: 3 } },
+      { rawItem: { id: 4 } },
+      { rawItem: { id: 5 } },
+      { rawItem: { id: 6 } },
+      { rawItem: { id: 7 } },
+      { rawItem: { id: 8 } }
+    ]);
+  });
+
+  it('should toElementFn', () => {
+    const heap = new Heap<number, { rawItem: { id: number } }>(
+      [
+        { rawItem: { id: 4 } },
+        { rawItem: { id: 8 } },
+        { rawItem: { id: 6 } },
+        { rawItem: { id: 7 } },
+        { rawItem: { id: 1 } },
+        { rawItem: { id: 3 } },
+        { rawItem: { id: 5 } }
+      ],
+      { toElementFn: rawElement => rawElement.rawItem.id }
+    );
+
+    expect([...heap.sort()]).toEqual([1, 3, 4, 5, 6, 7, 8]);
+  });
 });
 
 describe('FibonacciHeap', () => {

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -5,7 +5,7 @@ describe('MaxHeap', () => {
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap([], { comparator: numberComparator });
+    maxHeap = new MaxHeap<number>([], { comparator: numberComparator });
   });
 
   it('add and poll elements in descending order', () => {
@@ -49,4 +49,47 @@ describe('MaxHeap', () => {
     maxHeap.poll();
     expect(maxHeap.isEmpty()).toBe(true);
   });
+
+  it('should object heap map & filter', function () {
+    const maxHeap = new MaxHeap<{ a: string; key: number }>(
+      [
+        { key: 1, a: 'a1' },
+        { key: 6, a: 'a6' },
+        { key: 5, a: 'a5' },
+        { key: 3, a: 'a3' },
+        { key: 2, a: 'a2' },
+        { key: 4, a: 'a4' },
+        { key: 0, a: 'a0' }
+      ],
+      { comparator: (a, b) => b.key - a.key }
+    );
+
+    const mappedMaxHeap = maxHeap.map(
+      item => item.key,
+      (a, b) => b - a
+    );
+    expect(mappedMaxHeap.peek()).toBe(6);
+    expect(mappedMaxHeap.sort()).toEqual([6, 5, 4, 3, 2, 1, 0]);
+
+    const mappedToElementFnMaxHeap = maxHeap.map<
+      string,
+      {
+        id: string;
+      }
+    >(
+      item => item.key.toString(),
+      (a, b) => Number(b) - Number(a),
+      rawElement => rawElement.id
+    );
+    expect(mappedToElementFnMaxHeap.peek()).toBe('6');
+    expect(mappedToElementFnMaxHeap.sort()).toEqual(['6', '5', '4', '3', '2', '1', '0']);
+
+    const filteredHeap = maxHeap.filter(item => item.key > 3);
+    expect(filteredHeap.peek()).toEqual({ a: 'a6', key: 6 });
+    expect(filteredHeap.sort()).toEqual([
+      { a: 'a6', key: 6 },
+      { a: 'a5', key: 5 },
+      { a: 'a4', key: 4 }
+    ]);
+  });
 });

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -5,7 +5,7 @@ describe('MinHeap', () => {
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap([], { comparator: numberComparator });
+    minHeap = new MinHeap<number>([], { comparator: numberComparator });
   });
 
   it('add and poll elements in ascending order', () => {
@@ -40,6 +40,23 @@ describe('MinHeap', () => {
     expect(sortedArray).toEqual([1, 2, 3, 4]);
   });
 
+  it('should clone', function () {
+    const minHeap = new MinHeap<string>();
+    minHeap.add('1');
+    minHeap.add('6');
+    minHeap.add('2');
+    minHeap.add('0');
+    minHeap.add('5');
+    minHeap.add('9');
+    minHeap.delete('2');
+    expect([...minHeap]).toEqual(['0', '1', '9', '6', '5']);
+    const cloned = minHeap.clone();
+    expect([...cloned]).toEqual(['0', '1', '9', '6', '5']);
+    minHeap.delete('5');
+    expect([...minHeap]).toEqual(['0', '1', '9', '6']);
+    expect([...cloned]).toEqual(['0', '1', '9', '6', '5']);
+  });
+
   it('check if the heap is empty', () => {
     expect(minHeap.isEmpty()).toBe(true);
 

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -71,4 +71,46 @@ describe('MaxPriorityQueue Operation Test', () => {
     expect(maxPQ.poll()?.keyA).toBe(3);
     expect(maxPQ.poll()?.keyA).toBe(1);
   });
+
+  it('should object priority queue', () => {
+    const maxPQ = new MaxPriorityQueue<{ rawItem: { id: number } }>(
+      [
+        { rawItem: { id: 4 } },
+        { rawItem: { id: 8 } },
+        { rawItem: { id: 6 } },
+        { rawItem: { id: 7 } },
+        { rawItem: { id: 1 } },
+        { rawItem: { id: 3 } },
+        { rawItem: { id: 5 } }
+      ],
+      { comparator: (a, b) => b.rawItem.id - a.rawItem.id }
+    );
+
+    expect([...maxPQ.sort()]).toEqual([
+      { rawItem: { id: 8 } },
+      { rawItem: { id: 7 } },
+      { rawItem: { id: 6 } },
+      { rawItem: { id: 5 } },
+      { rawItem: { id: 4 } },
+      { rawItem: { id: 3 } },
+      { rawItem: { id: 1 } }
+    ]);
+  });
+
+  it('should toElementFn', () => {
+    const maxPQ = new MaxPriorityQueue<number, { rawItem: { id: number } }>(
+      [
+        { rawItem: { id: 4 } },
+        { rawItem: { id: 8 } },
+        { rawItem: { id: 6 } },
+        { rawItem: { id: 7 } },
+        { rawItem: { id: 1 } },
+        { rawItem: { id: 3 } },
+        { rawItem: { id: 5 } }
+      ],
+      { toElementFn: rawElement => rawElement.rawItem.id }
+    );
+
+    expect([...maxPQ.sort()]).toEqual([8, 7, 6, 5, 4, 3, 1]);
+  });
 });