tree-multimap-typed 2.2.3 → 2.2.4

package/dist/types/data-structures/binary-tree/avl-tree-counter.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeCounterOptions, BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, FamilyPosition, IterationType, RBTNColor } from '../../types';
+import type { AVLTreeCounterOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, EntryCallback, FamilyPosition, IterationType, RBTNColor } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree } from './avl-tree';
 /**
@@ -186,7 +186,7 @@ export declare class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new AVLTreeCounter with mapped entries.
      */
-    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): AVLTreeCounter<MK, MV, MR>;
+    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<AVLTreeCounterOptions<MK, MV, MR>>, thisArg?: unknown): AVLTreeCounter<MK, MV, MR>;
     /**
      * (Protected) Create an empty instance of the same concrete class.
      * @remarks Time O(1), Space O(1)

package/dist/types/data-structures/binary-tree/avl-tree-multi-map.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapOptions, AVLTreeOptions, ElemOf, EntryCallback, FamilyPosition, IterationType, RBTNColor } from '../../types';
+import type { AVLTreeMultiMapOptions, ElemOf, EntryCallback, FamilyPosition, IterationType, RBTNColor } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 import { IBinaryTree } from '../../interfaces';
 /**
@@ -160,7 +160,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new AVLTreeMultiMap when mapping to array values; see overloads.
      */
-    map<MK = K, MVArr extends unknown[] = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MVArr]>, options?: Partial<AVLTreeOptions<MK, MVArr, MR>>, thisArg?: unknown): AVLTreeMultiMap<MK, ElemOf<MVArr>, MR>;
+    map<MK = K, MVArr extends unknown[] = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MVArr]>, options?: Partial<AVLTreeMultiMapOptions<MK, MVArr, MR>>, thisArg?: unknown): AVLTreeMultiMap<MK, ElemOf<MVArr>, MR>;
     /**
      * Create a new tree by mapping each [key, values] bucket.
      * @remarks Time O(N log N), Space O(N)
@@ -172,7 +172,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new AVLTree when mapping to non-array values; see overloads.
      */
-    map<MK = K, MV = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MV]>, options?: Partial<AVLTreeOptions<MK, MV, MR>>, thisArg?: unknown): AVLTree<MK, MV, MR>;
+    map<MK = K, MV = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MV]>, options?: Partial<AVLTreeMultiMapOptions<MK, MV, MR>>, thisArg?: unknown): AVLTree<MK, MV, MR>;
     /**
      * (Protected) Create an empty instance of the same concrete class.
      * @remarks Time O(1), Space O(1)
@@ -182,7 +182,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<
      * @param [options] - Optional constructor options for the like-kind instance.
      * @returns An empty like-kind instance.
      */
-    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<AVLTreeOptions<TK, TV, TR>>): this;
+    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<AVLTreeMultiMapOptions<TK, TV, TR>>): this;
     /**
      * (Protected) Create a like-kind instance and seed it from an iterable.
      * @remarks Time O(N log N), Space O(N)
@@ -193,5 +193,5 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<
      * @param [options] - Options merged with the current snapshot.
      * @returns A like-kind AVLTree built from the iterable.
      */
-    protected _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>>): AVLTree<TK, TV, TR>;
+    protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | AVLTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<AVLTreeMultiMapOptions<TK, TV, TR>>): AVLTree<TK, TV, TR>;
 }

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

@@ -7,7 +7,6 @@
  */
 import { BST } from './bst';
 import type { AVLTreeOptions, BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, FamilyPosition, IterationType, RBTNColor } from '../../types';
-import { BSTOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 /**
  * Represents a Node in an AVL (Adelson-Velsky and Landis) Tree.
@@ -359,7 +358,7 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      * @param [options] - Options for the new tree.
      * @returns A new, empty tree.
      */
-    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<BSTOptions<TK, TV, TR>>): this;
+    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<AVLTreeOptions<TK, TV, TR>>): this;
     /**
      * (Protected) Creates a new instance of the same AVLTree constructor, potentially with different generic types.
      * @remarks Time O(N log N) (from constructor) due to processing the iterable.
@@ -369,7 +368,7 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      * @param [options] - Options for the new tree.
      * @returns A new AVLTree.
      */
-    protected _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>>): AVLTree<TK, TV, TR>;
+    protected _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>>): AVLTree<TK, TV, TR>;
     /**
      * (Protected) Swaps properties of two nodes, including height.
      * @remarks Time O(H) (due to `ensureNode`), but O(1) if nodes are passed directly.

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeOptions, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparable, Comparator, CP, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodePredicate, OptNode, RBTNColor } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparator, CP, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodePredicate, OptNode, RBTNColor } from '../../types';
 import { BinaryTree } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Range } from '../../common';
@@ -279,7 +279,7 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
      * @param [options] - Configuration options for the BST, including comparator.
      */
-    constructor(keysNodesEntriesOrRaws?: Iterable<K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: BSTOptions<K, V, R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<K | BSTNode | [K | null | undefined, V | undefined] | null | undefined | R>, options?: BSTOptions<K, V, R>);
     protected _root?: BSTNode<K, V>;
     /**
      * Gets the root node of the tree.
@@ -288,17 +288,16 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      * @returns The root node.
      */
     get root(): OptNode<BSTNode<K, V>>;
-    protected _isReverse: boolean;
     /**
-     * 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;
+    protected _createDefaultComparator(): Comparator<K>;
     /**
-     * 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>;
     /**
@@ -308,14 +307,6 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      * @returns The comparator function.
      */
     get comparator(): Comparator<K>;
-    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;
     /**
      * (Protected) Creates a new BST node.
      * @remarks Time O(1), Space O(1)
@@ -507,15 +498,44 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      * @param [thisArg] - `this` context for the callback.
      * @returns A new, mapped BST.
      */
-    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): BST<MK, MV, MR>;
+    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BSTOptions<MK, MV, MR>>, thisArg?: unknown): BST<MK, MV, MR>;
     /**
-     * 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;
+    deleteWhere(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>> | Range<K>, onlyOne?: boolean, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): BinaryTreeDeleteResult<BSTNode<K, V>>[];
     /**
      * (Protected) Core bound search implementation supporting all parameter types.
      * Unified logic for both lowerBound and upperBound.
@@ -593,7 +613,7 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
     protected _setRoot(v: OptNode<BSTNode<K, V>>): void;
     /**
      * (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.
@@ -607,5 +627,5 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      * @param key - The key of the node to delete.
      * @returns True if the node was found and deleted, false otherwise.
      */
-    private _deleteByKey;
+    protected _deleteByKey(key: K): boolean;
 }

package/dist/types/data-structures/binary-tree/red-black-tree.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BinaryTreeOptions, CRUD, EntryCallback, FamilyPosition, RBTNColor, RedBlackTreeOptions } from '../../types';
+import type { BinaryTreeDeleteResult, CRUD, EntryCallback, FamilyPosition, RBTNColor, RedBlackTreeOptions } from '../../types';
 import { BST } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any> {
@@ -261,7 +261,7 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
      * @param [thisArg] - See parameter type for details.
      * @returns A new RedBlackTree with mapped entries.
      */
-    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): RedBlackTree<MK, MV, MR>;
+    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<RedBlackTreeOptions<MK, MV, MR>>, thisArg?: unknown): RedBlackTree<MK, MV, MR>;
     protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<RedBlackTreeOptions<TK, TV, TR>>): this;
     protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | RedBlackTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<RedBlackTreeOptions<TK, TV, TR>>): RedBlackTree<TK, TV, TR>;
     protected _setRoot(v: RedBlackTreeNode<K, V> | undefined): void;

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

@@ -5,8 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, FamilyPosition, IterationType, RBTNColor, TreeCounterOptions } from '../../types';
-import { BSTOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, EntryCallback, FamilyPosition, IterationType, RBTNColor, TreeCounterOptions } from '../../types';
 import { BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree } from './red-black-tree';
@@ -188,7 +187,7 @@ export declare class TreeCounter<K = any, V = any, R = any> extends RedBlackTree
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new TreeCounter with mapped entries.
      */
-    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): TreeCounter<MK, MV, MR>;
+    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<TreeCounterOptions<MK, MV, MR>>, thisArg?: unknown): TreeCounter<MK, MV, MR>;
     /**
      * Deep copy this tree, preserving map mode and aggregate counts.
      * @remarks Time O(N), Space O(N)
@@ -204,7 +203,7 @@ export declare class TreeCounter<K = any, V = any, R = any> extends RedBlackTree
      * @param [options] - Optional constructor options for the like-kind instance.
      * @returns An empty like-kind instance.
      */
-    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<BSTOptions<TK, TV, TR>>): this;
+    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<TreeCounterOptions<TK, TV, TR>>): this;
     /**
      * (Protected) Create a like-kind instance and seed it from an iterable.
      * @remarks Time O(N log N), Space O(N)
@@ -215,7 +214,7 @@ export declare class TreeCounter<K = any, V = any, R = any> extends RedBlackTree
      * @param [options] - Options merged with the current snapshot.
      * @returns A like-kind TreeCounter built from the iterable.
      */
-    protected _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>>): TreeCounter<TK, TV, TR>;
+    protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | BSTNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<TreeCounterOptions<TK, TV, TR>>): TreeCounter<TK, TV, TR>;
     /**
      * (Protected) Normalize input into a node plus its effective value and count.
      * @remarks Time O(1), Space O(1)

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElemOf, EntryCallback, FamilyPosition, RBTNColor, RedBlackTreeOptions, TreeMultiMapOptions } from '../../types';
+import type { ElemOf, EntryCallback, FamilyPosition, RBTNColor, TreeMultiMapOptions } from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 import { IBinaryTree } from '../../interfaces';
 /**
@@ -307,8 +307,8 @@ export declare class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTre
      * @returns True if the value was removed; false if not found.
      */
     deleteValue(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined, value: V): boolean;
-    map<MK = K, MVArr extends unknown[] = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MVArr]>, options?: Partial<RedBlackTreeOptions<MK, MVArr, MR>>, thisArg?: unknown): TreeMultiMap<MK, ElemOf<MVArr>, MR>;
-    map<MK = K, MV = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MV]>, options?: Partial<RedBlackTreeOptions<MK, MV, MR>>, thisArg?: unknown): RedBlackTree<MK, MV, MR>;
+    map<MK = K, MVArr extends unknown[] = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MVArr]>, options?: Partial<TreeMultiMapOptions<MK, MVArr, MR>>, thisArg?: unknown): TreeMultiMap<MK, ElemOf<MVArr>, MR>;
+    map<MK = K, MV = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MV]>, options?: Partial<TreeMultiMapOptions<MK, MV, MR>>, thisArg?: unknown): RedBlackTree<MK, MV, MR>;
     /**
      * (Protected) Create an empty instance of the same concrete class.
      * @remarks Time O(1), Space O(1)
@@ -318,7 +318,7 @@ export declare class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTre
      * @param [options] - Optional constructor options for the like-kind instance.
      * @returns An empty like-kind instance.
      */
-    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<RedBlackTreeOptions<TK, TV, TR>>): this;
+    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<TreeMultiMapOptions<TK, TV, TR>>): this;
     /**
      * (Protected) Create a like-kind instance and seed it from an iterable.
      * @remarks Time O(N log N), Space O(N)
@@ -329,5 +329,5 @@ export declare class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTre
      * @param [options] - Options merged with the current snapshot.
      * @returns A like-kind RedBlackTree built from the iterable.
      */
-    protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | RedBlackTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<RedBlackTreeOptions<TK, TV, TR>>): RedBlackTree<TK, TV, TR>;
+    protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | RedBlackTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<TreeMultiMapOptions<TK, TV, TR>>): RedBlackTree<TK, TV, TR>;
 }

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

@@ -1,12 +1,12 @@
 import type { BinaryTreeOptions } from './binary-tree';
-import { Comparable } from '../../utils';
-import { OptValue } from '../../common';
-export type BSTOptions<K, V, R> = Omit<BinaryTreeOptions<K, V, R>, 'isDuplicate'> & {
-    specifyComparable?: (key: K) => Comparable;
-    isReverse?: boolean;
+import type { Comparator, OptValue } from '../../common';
+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;
 export type OptNode<NODE> = NODE | undefined;
 export type BSTNEntry<K, V> = [BSTNOptKey<K>, OptValue<V>];
 export type BSTNOptKeyOrNode<K, NODE> = BSTNOptKey<K> | NODE;
 export type BSTNRep<K, V, NODE> = BSTNEntry<K, V> | BSTNOptKeyOrNode<K, NODE>;
+export {};

package/dist/umd/tree-multimap-typed.js

@@ -2840,36 +2840,20 @@ var treeMultimapTyped = (() => {
     constructor(keysNodesEntriesOrRaws = [], options) {
       super([], options);
       __publicField(this, "_root");
-      __publicField(this, "_isReverse", false);
       /**
-       * The default comparator function.
-       * @remarks Time O(1) (or O(C) if `specifyComparable` is used, C is complexity of that function).
-       */
-      __publicField(this, "_comparator", (a, b) => {
-        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;
-      });
-      __publicField(this, "_specifyComparable");
+         * The comparator function used to determine the order of keys in the tree.
+      
+         * @remarks Time O(1) Space O(1)
+         */
+      __publicField(this, "_comparator");
       if (options) {
-        const { specifyComparable, isReverse } = options;
-        if (typeof specifyComparable === "function") this._specifyComparable = specifyComparable;
-        if (isReverse !== void 0) this._isReverse = isReverse;
+        if ("comparator" in options && options.comparator !== void 0) {
+          this._comparator = options.comparator;
+        } else {
+          this._comparator = this._createDefaultComparator();
+        }
+      } else {
+        this._comparator = this._createDefaultComparator();
       }
       if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
     }
@@ -2883,13 +2867,25 @@ var treeMultimapTyped = (() => {
       return this._root;
     }
     /**
-     * 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() {
-      return this._isReverse;
+    _createDefaultComparator() {
+      return (a, b) => {
+        debugger;
+        if (isComparable(a) && isComparable(b)) {
+          if (a > b) return 1;
+          if (a < b) return -1;
+          return 0;
+        }
+        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!`
+          );
+        }
+        return 0;
+      };
     }
     /**
      * Gets the comparator function used by the tree.
@@ -2900,15 +2896,6 @@ var treeMultimapTyped = (() => {
     get comparator() {
       return this._comparator;
     }
-    /**
-     * 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() {
-      return this._specifyComparable;
-    }
     /**
      * (Protected) Creates a new BST node.
      * @remarks Time O(1), Space O(1)
@@ -2950,7 +2937,7 @@ var treeMultimapTyped = (() => {
      * @returns True if the key is valid, false otherwise.
      */
     isValidKey(key) {
-      return isComparable(key, this._specifyComparable !== void 0);
+      return isComparable(key);
     }
     /**
      * Performs a Depth-First Search (DFS) traversal.
@@ -3040,8 +3027,8 @@ var treeMultimapTyped = (() => {
         if (!this.isRealNode(cur.left)) return false;
         if (isRange) {
           const range = keyNodeEntryOrPredicate;
-          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)) {
@@ -3055,8 +3042,8 @@ var treeMultimapTyped = (() => {
         if (!this.isRealNode(cur.right)) return false;
         if (isRange) {
           const range = keyNodeEntryOrPredicate;
-          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)) {
@@ -3377,31 +3364,55 @@ var treeMultimapTyped = (() => {
       return out;
     }
     /**
-     * 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.
      *
-     * @param predicate - A function to test each [key, value] pair.
-     * @returns True if a node was deleted, false otherwise.
-     */
-    deleteWhere(predicate) {
-      const stack = [];
-      let cur = this._root;
-      let index = 0;
-      while (stack.length > 0 || cur !== void 0) {
-        while (cur !== void 0 && cur !== null) {
-          stack.push(cur);
-          cur = cur.left;
-        }
-        const node = stack.pop();
-        if (!node) break;
-        const key = node.key;
-        const val = node.value;
-        if (predicate(key, val, index++, this)) {
-          return this._deleteByKey(key);
-        }
-        cur = node.right;
+     * @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).
+     *
+     * @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(keyNodeEntryOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+      const toDelete = this.search(
+        keyNodeEntryOrPredicate,
+        onlyOne,
+        (node) => node,
+        startNode,
+        iterationType
+      );
+      let results = [];
+      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.
@@ -3554,8 +3565,7 @@ var treeMultimapTyped = (() => {
     _snapshotOptions() {
       return {
         ...super._snapshotOptions(),
-        specifyComparable: this.specifyComparable,
-        isReverse: this.isReverse
+        comparator: this._comparator
       };
     }
     /**
@@ -3583,14 +3593,14 @@ var treeMultimapTyped = (() => {
     }
     /**
      * (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.
      */
     _compare(a, b) {
-      return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
+      return this._comparator(a, b);
     }
     /**
      * (Private) Deletes a node by its key.