data-structure-typed 2.2.5 → 2.2.6

package/dist/types/data-structures/base/iterable-entry-base.d.ts

@@ -96,6 +96,12 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * @remarks Time O(n), Space O(1)
      */
     reduce<U>(callbackfn: ReduceEntryCallback<K, V, U>, initialValue: U): U;
+    /**
+     * Converts data structure to `[key, value]` pairs.
+     * @returns Array of entries.
+     * @remarks Time O(n), Space O(n)
+     */
+    toArray(): [K, V][];
     /**
      * Visualize the iterable as an array of `[key, value]` pairs (or a custom string).
      * @returns Array of entries (default) or a string.

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

@@ -488,19 +488,8 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @returns An array containing deletion results (for compatibility with self-balancing trees).
      */
     delete(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
-    /**
-     * Searches the tree for nodes matching a predicate.
-     * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). Performs a full DFS (pre-order) scan of the tree. Time O(N), as it may visit every node. Space O(H) for the call stack (recursive) or explicit stack (iterative), where H is the tree height (O(N) worst-case).
-     *
-     * @template C - The type of the callback function.
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param [onlyOne=false] - If true, stops after finding the first match.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on matching nodes.
-     * @param [startNode=this._root] - The node to start the search from.
-     * @param [iterationType=this.iterationType] - Whether to use 'RECURSIVE' or 'ITERATIVE' search.
-     * @returns An array of results from the callback function for each matching node.
-     */
-    search<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, onlyOne?: boolean, callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    search(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, onlyOne?: boolean): (K | undefined)[];
+    search<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, onlyOne: boolean, callback: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Gets all nodes matching a predicate.
      * @remarks Time O(N) (via `search`). Space O(H) or O(N) (via `search`).
@@ -598,39 +587,12 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @returns The minimum height (-1 for empty, 0 for single node).
      */
     getMinHeight(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): number;
-    /**
-     * Gets the path from a given node up to the root.
-     * @remarks Time O(H), where H is the depth of the `beginNode`. O(N) worst-case. Space O(H) for the result array.
-     *
-     * @template C - The type of the callback function.
-     * @param beginNode - The node to start the path from.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on each node in the path.
-     * @param [isReverse=false] - If true, returns the path from root-to-node.
-     * @returns An array of callback results.
-     */
-    getPathToRoot<C extends NodeCallback<BinaryTreeNode<K, V> | undefined>>(beginNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, callback?: C, isReverse?: boolean): ReturnType<C>[];
-    /**
-     * Finds the leftmost node in a subtree (the node with the smallest key in a BST).
-     * @remarks Time O(H), where H is the height of the left spine. O(N) worst-case. Space O(H) for recursive/trampoline stack.
-     *
-     * @template C - The type of the callback function.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on the leftmost node.
-     * @param [startNode=this._root] - The subtree root to search from.
-     * @param [iterationType=this.iterationType] - The traversal method.
-     * @returns The callback result for the leftmost node.
-     */
-    getLeftMost<C extends NodeCallback<BinaryTreeNode<K, V> | undefined>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>;
-    /**
-     * Finds the rightmost node in a subtree (the node with the largest key in a BST).
-     * @remarks Time O(H), where H is the height of the right spine. O(N) worst-case. Space O(H) for recursive/trampoline stack.
-     *
-     * @template C - The type of the callback function.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on the rightmost node.
-     * @param [startNode=this._root] - The subtree root to search from.
-     * @param [iterationType=this.iterationType] - The traversal method.
-     * @returns The callback result for the rightmost node.
-     */
-    getRightMost<C extends NodeCallback<BinaryTreeNode<K, V> | undefined>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>;
+    getPathToRoot(beginNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): (K | undefined)[];
+    getPathToRoot<C extends NodeCallback<BinaryTreeNode<K, V> | undefined>>(beginNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, callback: C, isReverse?: boolean): ReturnType<C>[];
+    getLeftMost(): K | undefined;
+    getLeftMost<C extends NodeCallback<BinaryTreeNode<K, V> | undefined>>(callback: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>;
+    getRightMost(): K | undefined;
+    getRightMost<C extends NodeCallback<BinaryTreeNode<K, V> | undefined>>(callback: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>;
     /**
      * Gets the Morris traversal predecessor (rightmost node in the left subtree, or node itself).
      * @remarks This is primarily a helper for Morris traversal. Time O(H), where H is the height of the left subtree. O(N) worst-case. Space O(1).
@@ -647,23 +609,18 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @returns The successor node, or null/undefined if none exists.
      */
     getSuccessor(x?: K | BinaryTreeNode<K, V> | null): BinaryTreeNode<K, V> | null | undefined;
+    dfs(): (K | undefined)[];
     dfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
     dfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: boolean): ReturnType<C>[];
+    bfs(): (K | undefined)[];
     bfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
     bfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    /**
-     * Finds all leaf nodes in the tree.
-     * @remarks Time O(N), visits every node. Space O(H) for recursive stack or O(N) for iterative queue.
-     *
-     * @template C - The type of the callback function.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each leaf node.
-     * @param [startNode=this._root] - The node to start from.
-     * @param [iterationType=this.iterationType] - The traversal method.
-     * @returns An array of callback results.
-     */
-    leaves<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    leaves(): (K | undefined)[];
+    leaves<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    listLevels(): (K | undefined)[][];
     listLevels<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
     listLevels<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    morris(): (K | undefined)[];
     morris<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, pattern?: DFSOrderPattern, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): ReturnType<C>[];
     /**
      * Clones the tree.

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 { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparator, CP, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodePredicate, OptNode, RBTNColor } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparator, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodePredicate, OptNode, RBTNColor } from '../../types';
 import { BinaryTree } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Range } from '../../common';
@@ -257,7 +257,7 @@ export declare class BSTNode<K = any, V = any> {
  *       return findFirstCommon(path1, path2);
  *     };
  *
- *     function findFirstCommon(arr1: number[], arr2: number[]): number | undefined {
+ *     function findFirstCommon(arr1: (number | undefined)[], arr2: (number | undefined)[]): number | undefined {
  *       for (const num of arr1) {
  *         if (arr2.indexOf(num) !== -1) {
  *           return num;
@@ -335,41 +335,12 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      * @returns True if the key is valid, false otherwise.
      */
     isValidKey(key: any): key is K;
-    /**
-     * Performs a Depth-First Search (DFS) traversal.
-     * @remarks Time O(N), visits every node. Space O(log N) for the call/explicit stack. O(N) worst-case.
-     *
-     * @template C - The type of the callback function.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
-     * @param [pattern='IN'] - The traversal order ('IN', 'PRE', 'POST').
-     * @param [onlyOne=false] - If true, stops after the first callback.
-     * @param [startNode=this._root] - The node to start from.
-     * @param [iterationType=this.iterationType] - The traversal method.
-     * @returns An array of callback results.
-     */
-    dfs<C extends NodeCallback<BSTNode<K, V>>>(callback?: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
-    /**
-     * Performs a Breadth-First Search (BFS) or Level-Order traversal.
-     * @remarks Time O(N), visits every node. Space O(N) in the worst case for the queue.
-     *
-     * @template C - The type of the callback function.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
-     * @param [startNode=this._root] - The node to start from.
-     * @param [iterationType=this.iterationType] - The traversal method.
-     * @returns An array of callback results.
-     */
-    bfs<C extends NodeCallback<BSTNode<K, V>>>(callback?: C, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
-    /**
-     * Returns a 2D array of nodes, grouped by level.
-     * @remarks Time O(N), visits every node. Space O(N) for the result array and the queue/stack.
-     *
-     * @template C - The type of the callback function.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each node.
-     * @param [startNode=this._root] - The node to start from.
-     * @param [iterationType=this.iterationType] - The traversal method.
-     * @returns A 2D array of callback results.
-     */
-    listLevels<C extends NodeCallback<BSTNode<K, V>>>(callback?: C, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[][];
+    dfs(): (K | undefined)[];
+    dfs<C extends NodeCallback<BSTNode<K, V>>>(callback: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    bfs(): (K | undefined)[];
+    bfs<C extends NodeCallback<BSTNode<K, V>>>(callback: C, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    listLevels(): (K | undefined)[][];
+    listLevels<C extends NodeCallback<BSTNode<K, V>>>(callback: C, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[][];
     /**
      * Gets the first node matching a predicate.
      * @remarks Time O(log N) if searching by key, O(N) if searching by predicate. Space O(log N) or O(N).
@@ -380,33 +351,10 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      * @returns The first matching node, or undefined if not found.
      */
     getNode(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, startNode?: BSTNOptKeyOrNode<K, BSTNode<K, V>>, iterationType?: IterationType): OptNode<BSTNode<K, V>>;
-    /**
-     * Searches the tree for nodes matching a predicate, key, or range.
-     * @remarks This is an optimized search for a BST. If searching by key or range, it prunes branches.
-     * Time O(H + M) for key/range search (H=height, M=matches). O(N) for predicate search.
-     * Space O(log N) for the stack.
-     *
-     * @template C - The type of the callback function.
-     * @param keyNodeEntryOrPredicate - The key, node, entry, predicate, or range to search for.
-     * @param [onlyOne=false] - If true, stops after finding the first match.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on matching nodes.
-     * @param [startNode=this._root] - The node to start the search from.
-     * @param [iterationType=this.iterationType] - Whether to use 'RECURSIVE' or 'ITERATIVE' search.
-     * @returns An array of results from the callback function for each matching node.
-     */
-    search<C extends NodeCallback<BSTNode<K, V>>>(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>> | Range<K>, onlyOne?: boolean, callback?: C, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
-    /**
-     * Performs an optimized search for nodes within a given key range.
-     * @remarks Time O(H + M), where H is tree height and M is the number of matches.
-     *
-     * @template C - The type of the callback function.
-     * @param range - A `Range` object or a `[low, high]` tuple.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - A function to call on matching nodes.
-     * @param [startNode=this._root] - The node to start the search from.
-     * @param [iterationType=this.iterationType] - The traversal method.
-     * @returns An array of callback results.
-     */
-    rangeSearch<C extends NodeCallback<BSTNode<K, V>>>(range: Range<K> | [K, K], callback?: C, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    search(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>> | Range<K>, onlyOne?: boolean): (K | undefined)[];
+    search<C extends NodeCallback<BSTNode<K, V>>>(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>> | Range<K>, onlyOne: boolean, callback: C, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    rangeSearch(range: Range<K> | [K, K]): (K | undefined)[];
+    rangeSearch<C extends NodeCallback<BSTNode<K, V>>>(range: Range<K> | [K, K], callback: C, startNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Adds a new node to the BST based on key comparison.
      * @remarks Time O(log N), where H is tree height. O(N) worst-case (unbalanced tree), O(log N) average. Space O(1).
@@ -430,87 +378,59 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      */
     addMany(keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, BSTNode<K, V>>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
     /**
-     * Returns the first node with a key greater than or equal to the given key.
-     * This is equivalent to C++ std::lower_bound on a BST.
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * Time Complexity: O(log n) on average, O(h) where h is tree height.
+     * Returns the first key with a value >= target.
+     * Equivalent to Java TreeMap.ceiling.
+     * Time Complexity: O(log n) average, O(h) worst case.
      * Space Complexity: O(h) for recursion, O(1) for iteration.
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param iterationType The iteration type (RECURSIVE or ITERATIVE). Defaults to this.iterationType.
-     * @returns The first node with key >= given key, or undefined if no such node exists.
      */
-    lowerBound(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, iterationType?: IterationType): BSTNode<K, V> | undefined;
+    ceiling(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>): K | undefined;
     /**
-     * Returns the first node with a key strictly greater than the given key.
-     * This is equivalent to C++ std::upper_bound on a BST.
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * Time Complexity: O(log n) on average, O(h) where h is tree height.
+     * Returns the first node with a key >= target and applies callback.
+     * Time Complexity: O(log n) average, O(h) worst case.
      * Space Complexity: O(h) for recursion, O(1) for iteration.
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param iterationType The iteration type (RECURSIVE or ITERATIVE). Defaults to this.iterationType.
-     * @returns The first node with key > given key, or undefined if no such node exists.
      */
-    upperBound(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, iterationType?: IterationType): BSTNode<K, V> | undefined;
+    ceiling<C extends NodeCallback<BSTNode<K, V>>>(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, callback: C, iterationType?: IterationType): ReturnType<C>;
     /**
-     * Returns the first node with a key greater than or equal to the given key.
-     * This is equivalent to Java TreeMap.ceilingEntry().
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * @remarks Time Complexity: O(log n) on average, O(h) where h is tree height.
+     * Returns the first key with a value > target.
+     * Equivalent to Java TreeMap.higher.
+     * Time Complexity: O(log n) average, O(h) worst case.
      * Space Complexity: O(h) for recursion, O(1) for iteration.
-     *
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param [iterationType=this.iterationType] - The iteration type (RECURSIVE or ITERATIVE).
-     * @returns The first node with key >= given key, or undefined if no such node exists.
      */
-    ceilingEntry(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, iterationType?: IterationType): BSTNode<K, V> | undefined;
+    higher(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>): K | undefined;
     /**
-     * Returns the first node with a key strictly greater than the given key.
-     * This is equivalent to Java TreeMap.higherEntry().
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * @remarks Time Complexity: O(log n) on average, O(h) where h is tree height.
+     * Returns the first node with a key > target and applies callback.
+     * Time Complexity: O(log n) average, O(h) worst case.
      * Space Complexity: O(h) for recursion, O(1) for iteration.
-     *
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param [iterationType=this.iterationType] - The iteration type (RECURSIVE or ITERATIVE).
-     * @returns The first node with key > given key, or undefined if no such node exists.
      */
-    higherEntry(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, iterationType?: IterationType): BSTNode<K, V> | undefined;
+    higher<C extends NodeCallback<BSTNode<K, V>>>(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, callback: C, iterationType?: IterationType): ReturnType<C>;
     /**
-     * Returns the first node with a key less than or equal to the given key.
-     * This is equivalent to Java TreeMap.floorEntry().
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * @remarks Time Complexity: O(log n) on average, O(h) where h is tree height.
+     * Returns the first key with a value <= target.
+     * Equivalent to Java TreeMap.floor.
+     * Time Complexity: O(log n) average, O(h) worst case.
      * Space Complexity: O(h) for recursion, O(1) for iteration.
-     *
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param [iterationType=this.iterationType] - The iteration type (RECURSIVE or ITERATIVE).
-     * @returns The first node with key <= given key, or undefined if no such node exists.
      */
-    floorEntry(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, iterationType?: IterationType): BSTNode<K, V> | undefined;
+    floor(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>): K | undefined;
     /**
-     * Returns the first node with a key strictly less than the given key.
-     * This is equivalent to Java TreeMap.lowerEntry().
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * @remarks Time Complexity: O(log n) on average, O(h) where h is tree height.
+     * Returns the first node with a key <= target and applies callback.
+     * Time Complexity: O(log n) average, O(h) worst case.
      * Space Complexity: O(h) for recursion, O(1) for iteration.
-     *
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param [iterationType=this.iterationType] - The iteration type (RECURSIVE or ITERATIVE).
-     * @returns The first node with key < given key, or undefined if no such node exists.
      */
-    lowerEntry(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, iterationType?: IterationType): BSTNode<K, V> | undefined;
+    floor<C extends NodeCallback<BSTNode<K, V>>>(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, callback: C, iterationType?: IterationType): ReturnType<C>;
     /**
-     * Traverses the tree and returns nodes that are lesser or greater than a target node.
-     * @remarks Time O(N), as it performs a full traversal. Space O(log N) or O(N).
-     *
-     * @template C - The type of the callback function.
-     * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on matching nodes.
-     * @param [lesserOrGreater=-1] - -1 for lesser, 1 for greater, 0 for equal.
-     * @param [targetNode=this._root] - The node to compare against.
-     * @param [iterationType=this.iterationType] - The traversal method.
-     * @returns An array of callback results.
+     * Returns the first key with a value < target.
+     * Equivalent to Java TreeMap.lower.
+     * Time Complexity: O(log n) average, O(h) worst case.
+     * Space Complexity: O(h) for recursion, O(1) for iteration.
+     */
+    lower(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>): K | undefined;
+    /**
+     * Returns the first node with a key < target and applies callback.
+     * Time Complexity: O(log n) average, O(h) worst case.
+     * Space Complexity: O(h) for recursion, O(1) for iteration.
      */
-    lesserOrGreaterTraverse<C extends NodeCallback<BSTNode<K, V>>>(callback?: C, lesserOrGreater?: CP, targetNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    lower<C extends NodeCallback<BSTNode<K, V>>>(keyNodeEntryOrPredicate: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BSTNode<K, V>>, callback: C, iterationType?: IterationType): ReturnType<C>;
+    lesserOrGreaterTraverse(): (K | undefined)[];
+    lesserOrGreaterTraverse<C extends NodeCallback<BSTNode<K, V>>>(callback: C, lesserOrGreater?: number, targetNode?: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Rebuilds the tree to be perfectly balanced.
      * @remarks Time O(N) (O(N) for DFS, O(N) for sorted build). Space O(N) for node array and recursion stack.

package/dist/umd/data-structure-typed.js

@@ -256,6 +256,14 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    /**
+     * Converts data structure to `[key, value]` pairs.
+     * @returns Array of entries.
+     * @remarks Time O(n), Space O(n)
+     */
+    toArray() {
+      return [...this];
+    }
     /**
      * Visualize the iterable as an array of `[key, value]` pairs (or a custom string).
      * @returns Array of entries (default) or a string.
@@ -269,7 +277,6 @@ var dataStructureTyped = (() => {
      * @remarks Time O(n), Space O(n)
      */
     print() {
-      console.log(this.toVisual());
     }
   };
 
@@ -489,7 +496,6 @@ var dataStructureTyped = (() => {
      * Time O(n) due to materialization, Space O(n) for the intermediate representation.
      */
     print() {
-      console.log(this.toVisual());
     }
   };
 
@@ -6834,8 +6840,6 @@ var dataStructureTyped = (() => {
       this.high = high;
       this.includeLow = includeLow;
       this.includeHigh = includeHigh;
-      if (!(isComparable(low) && isComparable(high))) throw new RangeError("low or high is not comparable");
-      if (low > high) throw new RangeError("low must be less than or equal to high");
     }
     // Determine whether a key is within the range
     isInRange(key, comparator) {
@@ -8079,7 +8083,6 @@ var dataStructureTyped = (() => {
      * @param [startNode=this._root] - The node to start printing from.
      */
     print(options, startNode = this._root) {
-      console.log(this.toVisual(startNode, options));
     }
     /**
      * (Protected) Core DFS implementation.
@@ -8971,77 +8974,63 @@ var dataStructureTyped = (() => {
       else _iterate();
       return inserted;
     }
-    /**
-     * Returns the first node with a key greater than or equal to the given key.
-     * This is equivalent to C++ std::lower_bound on a BST.
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * Time Complexity: O(log n) on average, O(h) where h is tree height.
-     * Space Complexity: O(h) for recursion, O(1) for iteration.
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param iterationType The iteration type (RECURSIVE or ITERATIVE). Defaults to this.iterationType.
-     * @returns The first node with key >= given key, or undefined if no such node exists.
-     */
-    lowerBound(keyNodeEntryOrPredicate, iterationType = this.iterationType) {
-      return this._bound(keyNodeEntryOrPredicate, true, iterationType);
-    }
-    /**
-     * Returns the first node with a key strictly greater than the given key.
-     * This is equivalent to C++ std::upper_bound on a BST.
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * Time Complexity: O(log n) on average, O(h) where h is tree height.
-     * Space Complexity: O(h) for recursion, O(1) for iteration.
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param iterationType The iteration type (RECURSIVE or ITERATIVE). Defaults to this.iterationType.
-     * @returns The first node with key > given key, or undefined if no such node exists.
-     */
-    upperBound(keyNodeEntryOrPredicate, iterationType = this.iterationType) {
-      return this._bound(keyNodeEntryOrPredicate, false, iterationType);
-    }
-    /**
-     * Returns the first node with a key greater than or equal to the given key.
-     * This is equivalent to Java TreeMap.ceilingEntry().
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * @remarks Time Complexity: O(log n) on average, O(h) where h is tree height.
-     * Space Complexity: O(h) for recursion, O(1) for iteration.
-     *
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param [iterationType=this.iterationType] - The iteration type (RECURSIVE or ITERATIVE).
-     * @returns The first node with key >= given key, or undefined if no such node exists.
-     */
-    ceilingEntry(keyNodeEntryOrPredicate, iterationType = this.iterationType) {
-      return this.lowerBound(keyNodeEntryOrPredicate, iterationType);
+    ceiling(keyNodeEntryOrPredicate, callback = this._DEFAULT_NODE_CALLBACK, iterationType) {
+      let actualCallback = void 0;
+      let actualIterationType = this.iterationType;
+      if (typeof callback === "string") {
+        actualIterationType = callback;
+      } else if (callback) {
+        actualCallback = callback;
+        if (iterationType) {
+          actualIterationType = iterationType;
+        }
+      }
+      const node = this._bound(keyNodeEntryOrPredicate, true, actualIterationType);
+      if (!actualCallback) {
+        return node == null ? void 0 : node.key;
+      }
+      return node ? actualCallback(node) : void 0;
     }
-    /**
-     * Returns the first node with a key strictly greater than the given key.
-     * This is equivalent to Java TreeMap.higherEntry().
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * @remarks Time Complexity: O(log n) on average, O(h) where h is tree height.
-     * Space Complexity: O(h) for recursion, O(1) for iteration.
-     *
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param [iterationType=this.iterationType] - The iteration type (RECURSIVE or ITERATIVE).
-     * @returns The first node with key > given key, or undefined if no such node exists.
-     */
-    higherEntry(keyNodeEntryOrPredicate, iterationType = this.iterationType) {
-      return this.upperBound(keyNodeEntryOrPredicate, iterationType);
+    higher(keyNodeEntryOrPredicate, callback = this._DEFAULT_NODE_CALLBACK, iterationType) {
+      let actualCallback = void 0;
+      let actualIterationType = this.iterationType;
+      if (typeof callback === "string") {
+        actualIterationType = callback;
+      } else if (callback) {
+        actualCallback = callback;
+        if (iterationType) {
+          actualIterationType = iterationType;
+        }
+      }
+      const node = this._bound(keyNodeEntryOrPredicate, false, actualIterationType);
+      if (!actualCallback) {
+        return node == null ? void 0 : node.key;
+      }
+      return node ? actualCallback(node) : void 0;
     }
-    /**
-     * Returns the first node with a key less than or equal to the given key.
-     * This is equivalent to Java TreeMap.floorEntry().
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * @remarks Time Complexity: O(log n) on average, O(h) where h is tree height.
-     * Space Complexity: O(h) for recursion, O(1) for iteration.
-     *
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param [iterationType=this.iterationType] - The iteration type (RECURSIVE or ITERATIVE).
-     * @returns The first node with key <= given key, or undefined if no such node exists.
-     */
-    floorEntry(keyNodeEntryOrPredicate, iterationType = this.iterationType) {
+    floor(keyNodeEntryOrPredicate, callback = this._DEFAULT_NODE_CALLBACK, iterationType) {
       if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) {
+        if (typeof callback === "string" || !callback) {
+          return void 0;
+        }
         return void 0;
       }
+      let actualCallback = void 0;
+      let actualIterationType = this.iterationType;
+      if (typeof callback === "string") {
+        actualIterationType = callback;
+      } else if (callback) {
+        actualCallback = callback;
+        if (iterationType) {
+          actualIterationType = iterationType;
+        }
+      }
       if (this._isPredicate(keyNodeEntryOrPredicate)) {
-        return this._floorByPredicate(keyNodeEntryOrPredicate, iterationType);
+        const node = this._floorByPredicate(keyNodeEntryOrPredicate, actualIterationType);
+        if (!actualCallback) {
+          return node == null ? void 0 : node.key;
+        }
+        return node ? actualCallback(node) : void 0;
       }
       let targetKey;
       if (this.isNode(keyNodeEntryOrPredicate)) {
@@ -9049,6 +9038,9 @@ var dataStructureTyped = (() => {
       } else if (this.isEntry(keyNodeEntryOrPredicate)) {
         const key = keyNodeEntryOrPredicate[0];
         if (key === null || key === void 0) {
+          if (typeof callback === "string" || !callback) {
+            return void 0;
+          }
           return void 0;
         }
         targetKey = key;
@@ -9056,27 +9048,40 @@ var dataStructureTyped = (() => {
         targetKey = keyNodeEntryOrPredicate;
       }
       if (targetKey !== void 0) {
-        return this._floorByKey(targetKey, iterationType);
+        const node = this._floorByKey(targetKey, actualIterationType);
+        if (!actualCallback) {
+          return node == null ? void 0 : node.key;
+        }
+        return node ? actualCallback(node) : void 0;
+      }
+      if (typeof callback === "string" || !callback) {
+        return void 0;
       }
       return void 0;
     }
-    /**
-     * Returns the first node with a key strictly less than the given key.
-     * This is equivalent to Java TreeMap.lowerEntry().
-     * Supports RECURSIVE and ITERATIVE implementations.
-     * @remarks Time Complexity: O(log n) on average, O(h) where h is tree height.
-     * Space Complexity: O(h) for recursion, O(1) for iteration.
-     *
-     * @param keyNodeEntryOrPredicate - The key, node, entry, or predicate function to search for.
-     * @param [iterationType=this.iterationType] - The iteration type (RECURSIVE or ITERATIVE).
-     * @returns The first node with key < given key, or undefined if no such node exists.
-     */
-    lowerEntry(keyNodeEntryOrPredicate, iterationType = this.iterationType) {
+    lower(keyNodeEntryOrPredicate, callback, iterationType) {
       if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) {
+        if (typeof callback === "string" || !callback) {
+          return void 0;
+        }
         return void 0;
       }
+      let actualCallback = void 0;
+      let actualIterationType = this.iterationType;
+      if (typeof callback === "string") {
+        actualIterationType = callback;
+      } else if (callback) {
+        actualCallback = callback;
+        if (iterationType) {
+          actualIterationType = iterationType;
+        }
+      }
       if (this._isPredicate(keyNodeEntryOrPredicate)) {
-        return this._lowerByPredicate(keyNodeEntryOrPredicate, iterationType);
+        const node = this._lowerByPredicate(keyNodeEntryOrPredicate, actualIterationType);
+        if (!actualCallback) {
+          return node == null ? void 0 : node.key;
+        }
+        return node ? actualCallback(node) : void 0;
       }
       let targetKey;
       if (this.isNode(keyNodeEntryOrPredicate)) {
@@ -9084,6 +9089,9 @@ var dataStructureTyped = (() => {
       } else if (this.isEntry(keyNodeEntryOrPredicate)) {
         const key = keyNodeEntryOrPredicate[0];
         if (key === null || key === void 0) {
+          if (typeof callback === "string" || !callback) {
+            return void 0;
+          }
           return void 0;
         }
         targetKey = key;
@@ -9091,7 +9099,14 @@ var dataStructureTyped = (() => {
         targetKey = keyNodeEntryOrPredicate;
       }
       if (targetKey !== void 0) {
-        return this._lowerByKey(targetKey, iterationType);
+        const node = this._lowerByKey(targetKey, actualIterationType);
+        if (!actualCallback) {
+          return node == null ? void 0 : node.key;
+        }
+        return node ? actualCallback(node) : void 0;
+      }
+      if (typeof callback === "string" || !callback) {
+        return void 0;
       }
       return void 0;
     }
@@ -9280,7 +9295,6 @@ var dataStructureTyped = (() => {
      */
     _createDefaultComparator() {
       return (a, b) => {
-        debugger;
         if (isComparable(a) && isComparable(b)) {
           if (a > b) return 1;
           if (a < b) return -1;