heap-typed 1.51.5 → 1.51.8

package/README.md

@@ -45,8 +45,8 @@ Max Heap
     import {MinHeap, MaxHeap} from 'data-structure-typed';
     // /* or if you prefer */ import {MinHeap, MaxHeap} from 'heap-typed';
 
-    const minNumHeap = new MinHeap<number>();
-    minNumHeap.add(1).add(6).add(2).add(0).add(5).add(9);
+    const minNumHeap = new MinHeap<number>([1, 6, 2, 0, 5]);
+    minNumHeap.add(9);
     minNumHeap.has(1)        //  true
     minNumHeap.has(2)        //  true
     minNumHeap.poll()        //  0
@@ -54,6 +54,7 @@ Max Heap
     minNumHeap.peek()        //  2
     minNumHeap.has(1);       // false
     minNumHeap.has(2);       // true
+
     const arrFromHeap = minNumHeap.toArray();
     arrFromHeap.length       //  4
     arrFromHeap[0]           //  2
@@ -61,38 +62,33 @@ Max Heap
     arrFromHeap[2]           //  9
     arrFromHeap[3]           //  6
     minNumHeap.sort()        //  [2, 5, 6, 9]
+
+    const maxHeap = new MaxHeap<{ keyA: string }>([], {comparator: (a, b) => b.keyA - a.keyA});
+    const obj1 = {keyA: 'a1'}, obj6 = {keyA: 'a6'}, obj5 = {keyA: 'a5'}, obj2 = {keyA: 'a2'},
+        obj0 = {keyA: 'a0'}, obj9 = {keyA: 'a9'};
     
+    maxHeap.add(obj1);
+    maxHeap.has(obj1)                       // true
+    maxHeap.has(obj9)                       // false
+    maxHeap.add(obj6);
+    maxHeap.has(obj6)                       // true
+    maxHeap.add(obj5);
+    maxHeap.add(obj2);
+    maxHeap.add(obj0);
+    maxHeap.add(obj9);
+    maxHeap.has(obj9)                       // true
     
-    const maxHeap = new MaxHeap<{ keyA: string }>();
-    const myObj1 = {keyA: 'a1'}, myObj6 = {keyA: 'a6'}, myObj5 = {keyA: 'a5'}, myObj2 = {keyA: 'a2'},
-        myObj0 = {keyA: 'a0'}, myObj9 = {keyA: 'a9'};
-    maxHeap.add(1, myObj1);
-    maxHeap.has(myObj1)  // true
-    maxHeap.has(myObj9)  // false
-    maxHeap.add(6, myObj6);
-    maxHeap.has(myObj6)  // true
-    maxHeap.add(5, myObj5);
-    maxHeap.has(myObj5)  // true
-    maxHeap.add(2, myObj2);
-    maxHeap.has(myObj2)  // true
-    maxHeap.has(myObj6)  // true
-    maxHeap.add(0, myObj0);
-    maxHeap.has(myObj0)  // true
-    maxHeap.has(myObj9)  // false
-    maxHeap.add(9, myObj9);
-    maxHeap.has(myObj9)  // true
-    
-    const peek9 = maxHeap.peek(true);
-    peek9 && peek9.val && peek9.val.keyA  // 'a9'
+    const peek9 = maxHeap.peek();
+    console.log(peek9.keyA)                 // 'a9'
     
-    const heapToArr = maxHeap.toArray(true);
-    heapToArr.map(item => item?.val?.keyA)  // ['a9', 'a2', 'a6', 'a1', 'a0', 'a5']
+    const heapToArr = maxHeap.toArray();
+    console.log(heapToArr.map(ele => ele?.keyA));  // ['a9', 'a2', 'a6', 'a1', 'a0', 'a5']
     
     const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
     let i = 0;
     while (maxHeap.size > 0) {
-        const polled = maxHeap.poll(true);
-        polled && polled.val && polled.val.keyA  // values[i]
+        const polled = maxHeap.poll();
+        console.log(polled.keyA)           // values[i]
         i++;
     }
 ```
@@ -100,59 +96,55 @@ Max Heap
 #### JS
 
 ```javascript
-    const {MinHeap, MaxHeap} = require('data-structure-typed');
-    // /* or if you prefer */ const {MinHeap, MaxHeap} = require('heap-typed');
-
-    const minNumHeap = new MinHeap();
-    minNumHeap.add(1).add(6).add(2).add(0).add(5).add(9);
-    minNumHeap.has(1)        //  true
-    minNumHeap.has(2)        //  true
-    minNumHeap.poll()        //  0
-    minNumHeap.poll()        //  1
-    minNumHeap.peek()        //  2
-    minNumHeap.has(1);       // false
-    minNumHeap.has(2);       // true
-    const arrFromHeap = minNumHeap.toArray();
-    arrFromHeap.length       //  4
-    arrFromHeap[0]           //  2
-    arrFromHeap[1]           //  5
-    arrFromHeap[2]           //  9
-    arrFromHeap[3]           //  6
-    minNumHeap.sort()        //  [2, 5, 6, 9]
-    
-    
-    const maxHeap = new MaxHeap();
-    const myObj1 = {keyA: 'a1'}, myObj6 = {keyA: 'a6'}, myObj5 = {keyA: 'a5'}, myObj2 = {keyA: 'a2'},
-        myObj0 = {keyA: 'a0'}, myObj9 = {keyA: 'a9'};
-    maxHeap.add(1, myObj1);
-    maxHeap.has(myObj1)  // true
-    maxHeap.has(myObj9)  // false
-    maxHeap.add(6, myObj6);
-    maxHeap.has(myObj6)  // true
-    maxHeap.add(5, myObj5);
-    maxHeap.has(myObj5)  // true
-    maxHeap.add(2, myObj2);
-    maxHeap.has(myObj2)  // true
-    maxHeap.has(myObj6)  // true
-    maxHeap.add(0, myObj0);
-    maxHeap.has(myObj0)  // true
-    maxHeap.has(myObj9)  // false
-    maxHeap.add(9, myObj9);
-    maxHeap.has(myObj9)  // true
-    
-    const peek9 = maxHeap.peek(true);
-    peek9 && peek9.val && peek9.val.keyA  // 'a9'
-    
-    const heapToArr = maxHeap.toArray(true);
-    heapToArr.map(item => item?.val?.keyA)  // ['a9', 'a2', 'a6', 'a1', 'a0', 'a5']
-    
-    const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
-    let i = 0;
-    while (maxHeap.size > 0) {
-        const polled = maxHeap.poll(true);
-        polled && polled.val && polled.val.keyA  // values[i]
-        i++;
-    }
+const {MinHeap, MaxHeap} = require('data-structure-typed');
+// /* or if you prefer */ const {MinHeap, MaxHeap} = require('heap-typed');
+
+const minNumHeap = new MinHeap([1, 6, 2, 0, 5]);
+minNumHeap.add(9);
+minNumHeap.has(1)        //  true
+minNumHeap.has(2)        //  true
+minNumHeap.poll()        //  0
+minNumHeap.poll()        //  1
+minNumHeap.peek()        //  2
+minNumHeap.has(1);       // false
+minNumHeap.has(2);       // true
+
+const arrFromHeap = minNumHeap.toArray();
+arrFromHeap.length       //  4
+arrFromHeap[0]           //  2
+arrFromHeap[1]           //  5
+arrFromHeap[2]           //  9
+arrFromHeap[3]           //  6
+minNumHeap.sort()        //  [2, 5, 6, 9]
+
+const maxHeap = new MaxHeap([], {comparator: (a, b) => b.keyA - a.keyA});
+const obj1 = {keyA: 'a1'}, obj6 = {keyA: 'a6'}, obj5 = {keyA: 'a5'}, obj2 = {keyA: 'a2'},
+    obj0 = {keyA: 'a0'}, obj9 = {keyA: 'a9'};
+
+maxHeap.add(obj1);
+maxHeap.has(obj1)                       // true
+maxHeap.has(obj9)                       // false
+maxHeap.add(obj6);
+maxHeap.has(obj6)                       // true
+maxHeap.add(obj5);
+maxHeap.add(obj2);
+maxHeap.add(obj0);
+maxHeap.add(obj9);
+maxHeap.has(obj9)                       // true
+
+const peek9 = maxHeap.peek();
+console.log(peek9.keyA)             // 'a9'
+
+const heapToArr = maxHeap.toArray();
+console.log(heapToArr.map(ele => ele?.keyA));  // ['a9', 'a2', 'a6', 'a1', 'a0', 'a5']
+
+const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
+let i = 0;
+while (maxHeap.size > 0) {
+    const polled = maxHeap.poll();
+    console.log(polled.keyA)           // values[i]
+    i++;
+}
 ```
 
 

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

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, Comparable, IterationType, KeyOrNodeOrEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
+export declare class AVLTreeMultiMapNode<K extends Comparable, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -36,7 +36,7 @@ export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeM
 /**
  * The only distinction between a AVLTreeMultiMap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class AVLTreeMultiMap<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>, TREE extends AVLTreeMultiMap<K, V, NODE, TREE> = AVLTreeMultiMap<K, V, NODE, AVLTreeMultiMapNested<K, V, NODE>>> extends AVLTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
+export declare class AVLTreeMultiMap<K extends Comparable, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>, TREE extends AVLTreeMultiMap<K, V, NODE, TREE> = AVLTreeMultiMap<K, V, NODE, AVLTreeMultiMapNested<K, V, NODE>>> extends AVLTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
     constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: AVLTreeMultiMapOptions<K>);
     protected _count: number;
     /**
@@ -68,15 +68,6 @@ export declare class AVLTreeMultiMap<K = any, V = any, NODE extends AVLTreeMulti
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key: K, value?: V, count?: number): NODE;
-    /**
-     * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
-     * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
-     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
-     * the tree, respectively. These properties can be
-     * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
-     * default options. The returned value is casted as `TREE`.
-     */
     createTree(options?: AVLTreeMultiMapOptions<K>): TREE;
     /**
      * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.

package/dist/data-structures/binary-tree/avl-tree-multi-map.js

@@ -83,17 +83,8 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
     createNode(key, value, count) {
         return new AVLTreeMultiMapNode(key, value, count);
     }
-    /**
-     * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
-     * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
-     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
-     * the tree, respectively. These properties can be
-     * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
-     * default options. The returned value is casted as `TREE`.
-     */
     createTree(options) {
-        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
+        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
     /**
      * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
@@ -199,6 +190,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
         const deletedResult = [];
         if (!this.root)
             return deletedResult;
+        callback = this._ensureCallback(identifier, callback);
         const curr = (_a = this.getNode(identifier, callback)) !== null && _a !== void 0 ? _a : undefined;
         if (!curr)
             return deletedResult;

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

@@ -6,9 +6,9 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, Comparable, KeyOrNodeOrEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
-export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
+export declare class AVLTreeNode<K extends Comparable, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
     /**
      * The constructor function initializes a new instance of a class with a key and an optional value,
      * and sets the height property to 0.
@@ -40,7 +40,7 @@ export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
  */
-export declare class AVLTree<K = any, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>, TREE extends AVLTree<K, V, NODE, TREE> = AVLTree<K, V, NODE, AVLTreeNested<K, V, NODE>>> extends BST<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
+export declare class AVLTree<K extends Comparable, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>, TREE extends AVLTree<K, V, NODE, TREE> = AVLTree<K, V, NODE, AVLTreeNested<K, V, NODE>>> extends BST<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
     /**
      * The constructor function initializes an AVLTree object with optional keysOrNodesOrEntries and options.
      * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, NODE>`

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

@@ -83,7 +83,7 @@ class AVLTree extends bst_1.BST {
      * @returns a new AVLTree object.
      */
     createTree(options) {
-        return new AVLTree([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
+        return new AVLTree([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of AVLTreeNode.
@@ -138,8 +138,6 @@ class AVLTree extends bst_1.BST {
      * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._DEFAULT_CALLBACK) {
-        if (identifier instanceof AVLTreeNode)
-            callback = (node => node);
         const deletedResults = super.delete(identifier, callback);
         for (const { needBalanced } of deletedResults) {
             if (needBalanced) {
@@ -159,21 +157,21 @@ class AVLTree extends bst_1.BST {
      * if either `srcNode` or `destNode` is undefined.
      */
     _swapProperties(srcNode, destNode) {
-        srcNode = this.ensureNode(srcNode);
-        destNode = this.ensureNode(destNode);
-        if (srcNode && destNode) {
-            const { key, value, height } = destNode;
+        const srcNodeEnsured = this.ensureNode(srcNode);
+        const destNodeEnsured = this.ensureNode(destNode);
+        if (srcNodeEnsured && destNodeEnsured) {
+            const { key, value, height } = destNodeEnsured;
             const tempNode = this.createNode(key, value);
             if (tempNode) {
                 tempNode.height = height;
-                destNode.key = srcNode.key;
-                destNode.value = srcNode.value;
-                destNode.height = srcNode.height;
-                srcNode.key = tempNode.key;
-                srcNode.value = tempNode.value;
-                srcNode.height = tempNode.height;
+                destNodeEnsured.key = srcNodeEnsured.key;
+                destNodeEnsured.value = srcNodeEnsured.value;
+                destNodeEnsured.height = srcNodeEnsured.height;
+                srcNodeEnsured.key = tempNode.key;
+                srcNodeEnsured.value = tempNode.value;
+                srcNodeEnsured.height = tempNode.height;
             }
-            return destNode;
+            return destNodeEnsured;
         }
         return undefined;
     }

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

@@ -5,8 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, DFSOrderPattern, EntryCallback, KeyOrNodeOrEntry, NodeDisplayLayout } from '../../types';
-import { FamilyPosition, IterationType } from '../../types';
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, Comparable, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, KeyOrNodeOrEntry, NodeDisplayLayout } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from '../base';
 /**
@@ -14,7 +13,7 @@ import { IterableEntryBase } from '../base';
  * @template V - The type of data stored in the node.
  * @template NODE - The type of the family relationship in the binary tree.
  */
-export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
+export declare class BinaryTreeNode<K extends Comparable, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
     key: K;
     value?: V;
     parent?: NODE;
@@ -66,7 +65,7 @@ export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNod
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
  */
-export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, NODE, TREE> = BinaryTree<K, V, NODE, BinaryTreeNested<K, V, NODE>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, NODE, TREE> {
+export declare class BinaryTree<K extends Comparable, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, NODE, TREE> = BinaryTree<K, V, NODE, BinaryTreeNested<K, V, NODE>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, NODE, TREE> {
     iterationType: IterationType;
     /**
      * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
@@ -77,13 +76,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: BinaryTreeOptions<K>);
-    protected _extractor: (key: K) => number;
-    /**
-     * The function returns the value of the `_extractor` property.
-     * @returns The `_extractor` property is being returned.
-     */
-    get extractor(): (key: K) => number;
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: BinaryTreeOptions);
     protected _root?: NODE | null;
     /**
      * The function returns the root node, which can be of type NODE, null, or undefined.
@@ -117,7 +110,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * you can provide only a subset of the properties defined in the `BinaryTreeOptions` interface.
      * @returns a new instance of a binary tree.
      */
-    createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
+    createTree(options?: Partial<BinaryTreeOptions>): TREE;
     /**
      * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
@@ -254,7 +247,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getNodeByKey(key: K, iterationType?: IterationType): NODE | undefined;
+    getNodeByKey(key: K, iterationType?: IterationType): NODE | null | undefined;
     get<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
@@ -606,4 +599,5 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * type `NODE` or `null`.
      */
     protected _setRoot(v: NODE | null | undefined): void;
+    protected _ensureCallback<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback?: C): C;
 }