tree-multimap-typed 2.2.3 → 2.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-multimap-typed",
-  "version": "2.2.3",
+  "version": "2.2.4",
   "description": "Tree Multimap",
   "browser": "dist/umd/tree-multimap-typed.min.js",
   "umd:main": "dist/umd/tree-multimap-typed.min.js",
@@ -217,6 +217,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^2.2.3"
+    "data-structure-typed": "^2.2.4"
   }
 }

package/src/data-structures/binary-tree/avl-tree-counter.ts

@@ -9,7 +9,6 @@
 import type {
   AVLTreeCounterOptions,
   BinaryTreeDeleteResult,
-  BinaryTreeOptions,
   BSTNOptKeyOrNode,
   EntryCallback,
   FamilyPosition,
@@ -404,7 +403,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
    */
   override map<MK = K, MV = V, MR = any>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
-    options?: Partial<BinaryTreeOptions<MK, MV, MR>>,
+    options?: Partial<AVLTreeCounterOptions<MK, MV, MR>>,
     thisArg?: unknown
   ): AVLTreeCounter<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);

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

@@ -8,7 +8,6 @@
 
 import type {
   AVLTreeMultiMapOptions,
-  AVLTreeOptions,
   BTNOptKeyOrNull,
   ElemOf,
   EntryCallback,
@@ -354,7 +353,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
    */
   override map<MK = K, MVArr extends unknown[] = V[], MR = any>(
     callback: EntryCallback<K, V[] | undefined, [MK, MVArr]>,
-    options?: Partial<AVLTreeOptions<MK, MVArr, MR>>,
+    options?: Partial<AVLTreeMultiMapOptions<MK, MVArr, MR>>,
     thisArg?: unknown
   ): AVLTreeMultiMap<MK, ElemOf<MVArr>, MR>;
 
@@ -371,7 +370,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
    */
   override map<MK = K, MV = V[], MR = any>(
     callback: EntryCallback<K, V[] | undefined, [MK, MV]>,
-    options?: Partial<AVLTreeOptions<MK, MV, MR>>,
+    options?: Partial<AVLTreeMultiMapOptions<MK, MV, MR>>,
     thisArg?: unknown
   ): AVLTree<MK, MV, MR>;
 
@@ -388,7 +387,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
    */
   override map<MK, MV, MR extends object>(
     callback: EntryCallback<K, V[] | undefined, [MK, MV]>,
-    options?: Partial<AVLTreeOptions<MK, MV, MR>>,
+    options?: Partial<AVLTreeMultiMapOptions<MK, MV, MR>>,
     thisArg?: unknown
   ): AVLTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
@@ -406,10 +405,10 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
    * @param [options] - Optional constructor options for the like-kind instance.
    * @returns An empty like-kind instance.
    */
-  protected override _createInstance<TK = K, TV = V, TR = R>(options?: Partial<AVLTreeOptions<TK, TV, TR>>): this {
+  protected override _createInstance<TK = K, TV = V, TR = R>(options?: Partial<AVLTreeMultiMapOptions<TK, TV, TR>>): this {
     const Ctor = this.constructor as unknown as new (
       iter?: Iterable<TK | AVLTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>,
-      opts?: AVLTreeOptions<TK, TV, TR>
+      opts?: AVLTreeMultiMapOptions<TK, TV, TR>
     ) => AVLTree<TK, TV, TR>;
     return new Ctor([], { ...(this._snapshotOptions?.<TK, TV, TR>() ?? {}), ...(options ?? {}) }) as unknown as this;
   }
@@ -426,11 +425,11 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
    */
   protected override _createLike<TK = K, TV = V, TR = R>(
     iter: Iterable<TK | AVLTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR> = [],
-    options?: Partial<AVLTreeOptions<TK, TV, TR>>
+    options?: Partial<AVLTreeMultiMapOptions<TK, TV, TR>>
   ): AVLTree<TK, TV, TR> {
     const Ctor = this.constructor as unknown as new (
       iter?: Iterable<TK | AVLTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>,
-      opts?: AVLTreeOptions<TK, TV, TR>
+      opts?: AVLTreeMultiMapOptions<TK, TV, TR>
     ) => AVLTree<TK, TV, TR>;
     return new Ctor(iter, { ...(this._snapshotOptions?.<TK, TV, TR>() ?? {}), ...(options ?? {}) });
   }

package/src/data-structures/binary-tree/avl-tree.ts

@@ -17,7 +17,6 @@ import type {
   IterationType,
   RBTNColor
 } from '../../types';
-import { BSTOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
 /**
@@ -512,10 +511,10 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    * @param [options] - Options for the new tree.
    * @returns A new, empty tree.
    */
-  protected override _createInstance<TK = K, TV = V, TR = R>(options?: Partial<BSTOptions<TK, TV, TR>>): this {
+  protected override _createInstance<TK = K, TV = V, TR = R>(options?: Partial<AVLTreeOptions<TK, TV, TR>>): this {
     const Ctor = this.constructor as unknown as new (
       iter?: Iterable<TK | AVLTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>,
-      opts?: BSTOptions<TK, TV, TR>
+      opts?: AVLTreeOptions<TK, TV, TR>
     ) => this;
     return new Ctor([], { ...this._snapshotOptions<TK, TV, TR>(), ...(options ?? {}) }) as unknown as this;
   }
@@ -531,11 +530,11 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    */
   protected override _createLike<TK = K, TV = V, TR = R>(
     iter: Iterable<TK | AVLTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR> = [],
-    options?: Partial<BSTOptions<TK, TV, TR>>
+    options?: Partial<AVLTreeOptions<TK, TV, TR>>
   ): AVLTree<TK, TV, TR> {
     const Ctor = this.constructor as unknown as new (
       iter?: Iterable<TK | AVLTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>,
-      opts?: BSTOptions<TK, TV, TR>
+      opts?: AVLTreeOptions<TK, TV, TR>
     ) => AVLTree<TK, TV, TR>;
     return new Ctor(iter, { ...this._snapshotOptions<TK, TV, TR>(), ...(options ?? {}) });
   }

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

@@ -7,11 +7,10 @@
  */
 
 import type {
-  BinaryTreeOptions,
+  BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
   BSTOptions,
   BTNRep,
-  Comparable,
   Comparator,
   CP,
   DFSOrderPattern,
@@ -356,20 +355,28 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    */
   constructor(
     keysNodesEntriesOrRaws: Iterable<
-      K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+      K | BSTNode | [K | null | undefined, V | undefined] | null | undefined | R
     > = [],
     options?: BSTOptions<K, V, R>
   ) {
     super([], options);
 
     if (options) {
-      const { specifyComparable, isReverse } = options;
-      if (typeof specifyComparable === 'function') this._specifyComparable = specifyComparable;
-      if (isReverse !== undefined) this._isReverse = isReverse;
+
+      // Use the 'in' operator to check if the field is present
+      if ('comparator' in options && options.comparator !== undefined) {
+        this._comparator = options.comparator;
+      } else {
+        this._comparator = this._createDefaultComparator();
+      }
+    } else {
+      this._comparator = this._createDefaultComparator();
     }
+
     if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
   }
 
+
   protected override _root?: BSTNode<K, V> = undefined;
 
   /**
@@ -382,42 +389,40 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     return this._root;
   }
 
-  protected _isReverse: boolean = false;
-
   /**
-   * Gets whether the tree's comparison logic is reversed.
-   * @remarks Time O(1)
-   *
-   * @returns True if the tree is reversed (e.g., a max-heap logic).
+   * (Protected) Creates the default comparator function for keys that don't have a custom comparator.
+   * @remarks Time O(1) Space O(1)
+   * @returns The default comparator function.
    */
-  get isReverse(): boolean {
-    return this._isReverse;
+  protected _createDefaultComparator(): Comparator<K> {
+    return (a: K, b: K): number => {
+      debugger
+      // If both keys are comparable (primitive types), use direct comparison
+      if (isComparable(a) && isComparable(b)) {
+        if (a > b) return 1;
+        if (a < b) return -1;
+        return 0;
+      }
+
+      // If keys are objects and no comparator is provided, throw an error
+      if (typeof a === 'object' || typeof b === 'object') {
+        throw TypeError(
+          `When comparing object type keys, a custom comparator must be provided in the constructor's options!`
+        );
+      }
+
+      // Default: keys are equal (fallback case)
+      return 0;
+    };
   }
 
   /**
-   * The default comparator function.
-   * @remarks Time O(1) (or O(C) if `specifyComparable` is used, C is complexity of that function).
+   * The comparator function used to determine the order of keys in the tree.
+
+   * @remarks Time O(1) Space O(1)
    */
-  protected _comparator: Comparator<K> = (a: K, b: K): number => {
-    if (isComparable(a) && isComparable(b)) {
-      if (a > b) return 1;
-      if (a < b) return -1;
-      return 0;
-    }
-    if (this._specifyComparable) {
-      const va = this._specifyComparable(a);
-      const vb = this._specifyComparable(b);
-      if (va > vb) return 1;
-      if (va < vb) return -1;
-      return 0;
-    }
-    if (typeof a === 'object' || typeof b === 'object') {
-      throw TypeError(
-        `When comparing object types, a custom specifyComparable must be defined in the constructor's options.`
-      );
-    }
-    return 0;
-  };
+  protected _comparator: Comparator<K>;
+
 
   /**
    * Gets the comparator function used by the tree.
@@ -429,18 +434,6 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     return this._comparator;
   }
 
-  protected _specifyComparable?: (key: K) => Comparable;
-
-  /**
-   * Gets the function used to extract a comparable value from a complex key.
-   * @remarks Time O(1)
-   *
-   * @returns The key-to-comparable conversion function.
-   */
-  get specifyComparable(): ((key: K) => Comparable) | undefined {
-    return this._specifyComparable;
-  }
-
   /**
    * (Protected) Creates a new BST node.
    * @remarks Time O(1), Space O(1)
@@ -489,7 +482,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @returns True if the key is valid, false otherwise.
    */
   override isValidKey(key: any): key is K {
-    return isComparable(key, this._specifyComparable !== undefined);
+    return isComparable(key);
   }
 
   /**
@@ -625,8 +618,8 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       if (isRange) {
         // Range search: Only go left if the current key is >= the lower bound
         const range = keyNodeEntryOrPredicate as Range<K>;
-        const leftS = this.isReverse ? range.high : range.low;
-        const leftI = this.isReverse ? range.includeHigh : range.includeLow;
+        const leftS =  range.low;
+        const leftI =  range.includeLow;
         return (leftI && this._compare(cur.key, leftS) >= 0) || (!leftI && this._compare(cur.key, leftS) > 0);
       }
       if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
@@ -643,8 +636,8 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       if (isRange) {
         // Range search: Only go right if current key <= upper bound
         const range = keyNodeEntryOrPredicate as Range<K>;
-        const rightS = this.isReverse ? range.low : range.high;
-        const rightI = this.isReverse ? range.includeLow : range.includeHigh;
+        const rightS =  range.high;
+        const rightI =  range.includeHigh;
         return (rightI && this._compare(cur.key, rightS) <= 0) || (!rightI && this._compare(cur.key, rightS) < 0);
       }
       if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
@@ -1037,7 +1030,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    */
   override map<MK = K, MV = V, MR = any>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
-    options?: Partial<BinaryTreeOptions<MK, MV, MR>>,
+    options?: Partial<BSTOptions<MK, MV, MR>>,
     thisArg?: unknown
   ): BST<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
@@ -1050,36 +1043,73 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
   }
 
   /**
-   * Deletes the first node found that satisfies the predicate.
-   * @remarks Performs an in-order traversal. Time O(N) worst-case (O(log N) to find + O(log N) to delete). Space O(log N) for stack.
+   * Deletes nodes that match a key, node, entry, predicate, or range.
+   *
+   * @remarks
+   * Time Complexity: O(N) for search + O(M log N) for M deletions, where N is tree size.
+   * Space Complexity: O(M) for storing matched nodes and result map.
+   *
+   * @template K - The key type.
+   * @template V - The value type.
+   *
+   * @param keyNodeEntryOrPredicate - The search criteria. Can be one of:
+   *   - A key (type K): searches for exact key match using the comparator.
+   *   - A BSTNode: searches for the matching node in the tree.
+   *   - An entry tuple: searches for the key-value pair.
+   *   - A NodePredicate function: tests each node and returns true for matches.
+   *   - A Range object: searches for nodes whose keys fall within the specified range (inclusive/exclusive based on range settings).
+   *   - null or undefined: treated as no match, returns empty results.
+   *
+   * @param onlyOne - If true, stops the search after finding the first match and only deletes that one node.
+   *   If false (default), searches for and deletes all matching nodes.
+   *
+   * @param startNode - The node to start the search from. Can be:
+   *   - A key, node, or entry: the method resolves it to a node and searches from that subtree.
+   *   - null or undefined: defaults to the root, searching the entire tree.
+   *   - Default value: this._root (the tree's root).
+   *
+   * @param iterationType - Controls the internal traversal implementation:
+   *   - 'RECURSIVE': uses recursive function calls for traversal.
+   *   - 'ITERATIVE': uses explicit stack-based iteration.
+   *   - Default: this.iterationType (the tree's default iteration mode).
    *
-   * @param predicate - A function to test each [key, value] pair.
-   * @returns True if a node was deleted, false otherwise.
+   * @returns A Map<K, boolean> containing the deletion results:
+   *   - Key: the matched node's key.
+   *   - Value: true if the deletion succeeded, false if it failed (e.g., key not found during deletion phase).
+   *   - If no nodes match the search criteria, the returned map is empty.
    */
-  deleteWhere(predicate: (key: K, value: V | undefined, index: number, tree: this) => boolean): boolean {
-    const stack: Array<BSTNode<K, V> | null | undefined> = [];
-    let cur = this._root as BSTNode<K, V> | null | undefined;
-    let index = 0;
+  deleteWhere(
+    keyNodeEntryOrPredicate:
+      | K
+      | BSTNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BSTNode<K, V>>
+      | Range<K>,
+    onlyOne = false,
+    startNode: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
+    iterationType: IterationType = this.iterationType
+  ):  BinaryTreeDeleteResult<BSTNode<K, V>>[] {
 
-    // In-order traversal to find the node
-    while (stack.length > 0 || cur !== undefined) {
-      while (cur !== undefined && cur !== null) {
-        stack.push(cur);
-        cur = cur.left as BSTNode<K, V> | null | undefined;
-      }
-      const node = stack.pop() as BSTNode<K, V> | undefined;
-      if (!node) break;
+    const toDelete = this.search (
+      keyNodeEntryOrPredicate,
+      onlyOne,
+      (node) => node,
+      startNode,
+      iterationType
+    );
 
-      const key = node.key as K;
-      const val = node.value as V | undefined;
-      if (predicate(key, val, index++, this)) {
-        return this._deleteByKey(key); // Found, now delete
-      }
-      cur = node.right as BSTNode<K, V> | null | undefined;
+    let results : BinaryTreeDeleteResult<BSTNode<K, V>>[] = [];
+    for (const node of toDelete) {
+      const deleteInfo = this.delete(node);
+      results = results.concat(deleteInfo);
     }
-    return false;
+
+    return results;
   }
 
+
   /**
    * (Protected) Core bound search implementation supporting all parameter types.
    * Unified logic for both lowerBound and upperBound.
@@ -1300,8 +1330,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
   protected override _snapshotOptions<TK = K, TV = V, TR = R>(): BSTOptions<TK, TV, TR> {
     return {
       ...super._snapshotOptions<TK, TV, TR>(),
-      specifyComparable: this.specifyComparable as BSTOptions<TK, TV, TR>['specifyComparable'],
-      isReverse: this.isReverse as BSTOptions<TK, TV, TR>['isReverse']
+      comparator: this._comparator as unknown as BSTOptions<TK, TV, TR>['comparator'],
     };
   }
 
@@ -1335,14 +1364,14 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
 
   /**
    * (Protected) Compares two keys using the tree's comparator and reverse setting.
-   * @remarks Time O(1) (or O(C) if `specifyComparable` is used).
+   * @remarks Time O(1) Space O(1)
    *
    * @param a - The first key.
    * @param b - The second key.
    * @returns A number (1, -1, or 0) representing the comparison.
    */
   protected _compare(a: K, b: K) {
-    return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
+    return this._comparator(a, b);
   }
 
   /**
@@ -1352,7 +1381,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @param key - The key of the node to delete.
    * @returns True if the node was found and deleted, false otherwise.
    */
-  private _deleteByKey(key: K): boolean {
+  protected _deleteByKey(key: K): boolean {
     let node = this._root as BSTNode<K, V> | undefined;
 
     // 1. Find the node

package/src/data-structures/binary-tree/red-black-tree.ts

@@ -8,7 +8,6 @@
 
 import type {
   BinaryTreeDeleteResult,
-  BinaryTreeOptions,
   CRUD,
   EntryCallback,
   FamilyPosition,
@@ -463,7 +462,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
 
   override map<MK = K, MV = V, MR = any>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
-    options?: Partial<BinaryTreeOptions<MK, MV, MR>>,
+    options?: Partial<RedBlackTreeOptions<MK, MV, MR>>,
     thisArg?: unknown
   ): RedBlackTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);

package/src/data-structures/binary-tree/tree-counter.ts

@@ -8,7 +8,6 @@
 
 import type {
   BinaryTreeDeleteResult,
-  BinaryTreeOptions,
   BSTNOptKeyOrNode,
   EntryCallback,
   FamilyPosition,
@@ -17,7 +16,6 @@ import type {
   RBTNColor,
   TreeCounterOptions
 } from '../../types';
-import { BSTOptions } from '../../types';
 import { BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree } from './red-black-tree';
@@ -432,7 +430,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
    */
   override map<MK = K, MV = V, MR = any>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
-    options?: Partial<BinaryTreeOptions<MK, MV, MR>>,
+    options?: Partial<TreeCounterOptions<MK, MV, MR>>,
     thisArg?: unknown
   ): TreeCounter<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
@@ -465,10 +463,10 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
    * @param [options] - Optional constructor options for the like-kind instance.
    * @returns An empty like-kind instance.
    */
-  protected override _createInstance<TK = K, TV = V, TR = R>(options?: Partial<BSTOptions<TK, TV, TR>>): this {
+  protected override _createInstance<TK = K, TV = V, TR = R>(options?: Partial<TreeCounterOptions<TK, TV, TR>>): this {
     const Ctor = this.constructor as unknown as new (
       iter?: Iterable<TK | BSTNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>,
-      opts?: BSTOptions<TK, TV, TR>
+      opts?: TreeCounterOptions<TK, TV, TR>
     ) => this;
     return new Ctor([], { ...this._snapshotOptions<TK, TV, TR>(), ...(options ?? {}) }) as unknown as this;
   }
@@ -485,11 +483,11 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
    */
   protected override _createLike<TK = K, TV = V, TR = R>(
     iter: Iterable<TK | BSTNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR> = [],
-    options?: Partial<BSTOptions<TK, TV, TR>>
+    options?: Partial<TreeCounterOptions<TK, TV, TR>>
   ): TreeCounter<TK, TV, TR> {
     const Ctor = this.constructor as unknown as new (
       iter?: Iterable<TK | BSTNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>,
-      opts?: BSTOptions<TK, TV, TR>
+      opts?: TreeCounterOptions<TK, TV, TR>
     ) => TreeCounter<TK, TV, TR>;
     return new Ctor(iter as unknown as Iterable<TK | any>, {
       ...this._snapshotOptions<TK, TV, TR>(),

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

@@ -12,7 +12,6 @@ import type {
   EntryCallback,
   FamilyPosition,
   RBTNColor,
-  RedBlackTreeOptions,
   TreeMultiMapOptions
 } from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
@@ -476,13 +475,13 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
 
   override map<MK = K, MVArr extends unknown[] = V[], MR = any>(
     callback: EntryCallback<K, V[] | undefined, [MK, MVArr]>,
-    options?: Partial<RedBlackTreeOptions<MK, MVArr, MR>>,
+    options?: Partial<TreeMultiMapOptions<MK, MVArr, MR>>,
     thisArg?: unknown
   ): TreeMultiMap<MK, ElemOf<MVArr>, MR>;
 
   override map<MK = K, MV = V[], MR = any>(
     callback: EntryCallback<K, V[] | undefined, [MK, MV]>,
-    options?: Partial<RedBlackTreeOptions<MK, MV, MR>>,
+    options?: Partial<TreeMultiMapOptions<MK, MV, MR>>,
     thisArg?: unknown
   ): RedBlackTree<MK, MV, MR>;
 
@@ -499,7 +498,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
    */
   override map<MK, MV, MR extends object>(
     callback: EntryCallback<K, V[] | undefined, [MK, MV]>,
-    options?: Partial<RedBlackTreeOptions<MK, MV, MR>>,
+    options?: Partial<TreeMultiMapOptions<MK, MV, MR>>,
     thisArg?: unknown
   ): RedBlackTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
@@ -517,10 +516,10 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
    * @param [options] - Optional constructor options for the like-kind instance.
    * @returns An empty like-kind instance.
    */
-  protected override _createInstance<TK = K, TV = V, TR = R>(options?: Partial<RedBlackTreeOptions<TK, TV, TR>>): this {
+  protected override _createInstance<TK = K, TV = V, TR = R>(options?: Partial<TreeMultiMapOptions<TK, TV, TR>>): this {
     const Ctor = this.constructor as unknown as new (
       iter?: Iterable<TK | RedBlackTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>,
-      opts?: RedBlackTreeOptions<TK, TV, TR>
+      opts?: TreeMultiMapOptions<TK, TV, TR>
     ) => RedBlackTree<TK, TV, TR>;
     return new Ctor([], { ...(this._snapshotOptions?.<TK, TV, TR>() ?? {}), ...(options ?? {}) }) as unknown as this;
   }
@@ -539,11 +538,11 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
     iter: Iterable<
       TK | RedBlackTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR
     > = [],
-    options?: Partial<RedBlackTreeOptions<TK, TV, TR>>
+    options?: Partial<TreeMultiMapOptions<TK, TV, TR>>
   ): RedBlackTree<TK, TV, TR> {
     const Ctor = this.constructor as unknown as new (
       iter?: Iterable<TK | RedBlackTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>,
-      opts?: RedBlackTreeOptions<TK, TV, TR>
+      opts?: TreeMultiMapOptions<TK, TV, TR>
     ) => RedBlackTree<TK, TV, TR>;
     return new Ctor(iter, { ...(this._snapshotOptions?.<TK, TV, TR>() ?? {}), ...(options ?? {}) });
   }

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

@@ -1,10 +1,10 @@
 import type { BinaryTreeOptions } from './binary-tree';
-import { Comparable } from '../../utils';
-import { OptValue } from '../../common';
+import type { Comparator, OptValue } from '../../common';
 
-export type BSTOptions<K, V, R> = Omit<BinaryTreeOptions<K, V, R>, 'isDuplicate'> & {
-  specifyComparable?: (key: K) => Comparable
-  isReverse?: boolean;
+type BSTBaseOptions<K, V, R> = Omit<BinaryTreeOptions<K, V, R>, 'isDuplicate'>;
+
+export type BSTOptions<K, V, R> = BSTBaseOptions<K, V, R> & {
+  comparator?: Comparator<K>;
 }
 
 export type BSTNOptKey<K> = K | undefined;