doubly-linked-list-typed 1.52.6 → 1.52.8

package/dist/constants/index.d.ts

@@ -0,0 +1,4 @@
+export declare enum DFSOperation {
+    VISIT = 0,
+    PROCESS = 1
+}

package/dist/constants/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DFSOperation = void 0;
+var DFSOperation;
+(function (DFSOperation) {
+    DFSOperation[DFSOperation["VISIT"] = 0] = "VISIT";
+    DFSOperation[DFSOperation["PROCESS"] = 1] = "PROCESS";
+})(DFSOperation = exports.DFSOperation || (exports.DFSOperation = {}));

package/dist/data-structures/base/iterable-element-base.d.ts

@@ -125,7 +125,14 @@ export declare abstract class IterableElementBase<E, R, C> {
      *
      * The print function logs the elements of an array to the console.
      */
-    print(): E[];
+    toVisual(): E[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The print function logs the elements of an array to the console.
+     */
+    print(): void;
     abstract isEmpty(): boolean;
     abstract clear(): void;
     abstract clone(): C;

package/dist/data-structures/base/iterable-element-base.js

@@ -182,8 +182,17 @@ class IterableElementBase {
      *
      * The print function logs the elements of an array to the console.
      */
-    print() {
+    toVisual() {
         return [...this];
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The print function logs the elements of an array to the console.
+     */
+    print() {
+        console.log(this.toVisual());
+    }
 }
 exports.IterableElementBase = IterableElementBase;

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

@@ -151,7 +151,14 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      *
      * The print function logs the elements of an array to the console.
      */
-    print(): [K, V][] | string;
+    toVisual(): [K, V][] | string;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The print function logs the elements of an array to the console.
+     */
+    print(): void;
     abstract isEmpty(): boolean;
     abstract clear(): void;
     abstract clone(): any;

package/dist/data-structures/base/iterable-entry-base.js

@@ -2,15 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IterableEntryBase = void 0;
 class IterableEntryBase {
-    // protected _toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
-    //
-    // /**
-    //  * The function returns the value of the _toEntryFn property.
-    //  * @returns The function being returned is `this._toEntryFn`.
-    //  */
-    // get toEntryFn() {
-    //   return this._toEntryFn;
-    // }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -233,8 +224,17 @@ class IterableEntryBase {
      *
      * The print function logs the elements of an array to the console.
      */
-    print() {
+    toVisual() {
         return [...this];
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The print function logs the elements of an array to the console.
+     */
+    print() {
+        console.log(this.toVisual());
+    }
 }
 exports.IterableEntryBase = IterableEntryBase;

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

@@ -1,12 +1,11 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, BTNKeyOrNodeOrEntry, IterationType } from '../../types';
-import { BTNEntry } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, BTNPredicate, IterationType, BTNEntry } 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> {
@@ -40,13 +39,13 @@ export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeM
 export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>, TREE extends AVLTreeMultiMap<K, V, R, NODE, TREE> = AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMapNested<K, V, R, NODE>>> extends AVLTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
-     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the AVLTreeMultiMap. It can include properties such as `compareKeys` and
      * `compareValues` functions to define custom comparison logic for keys and values, respectively.
      */
-    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: AVLTreeMultiMapOptions<K, V, R>);
+    constructor(keysOrNodesOrEntriesOrRaws?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: AVLTreeMultiMapOptions<K, V, R>);
     protected _count: number;
     /**
      * The function calculates the sum of the count property of all nodes in a tree using depth-first
@@ -85,17 +84,17 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
     createTree(options?: AVLTreeMultiMapOptions<K, V, R>): TREE;
     /**
      * The function checks if the input is an instance of AVLTreeMultiMapNode.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
      * an instance of the `AVLTreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
+    isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE;
     /**
      * The function `keyValueOrEntryOrRawElementToNode` converts a key, value, entry, or raw element into
      * a node object.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-     * `keyOrNodeOrEntryOrRawElement` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
+     * `keyOrNodeOrEntryOrRaw` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `override` function. It represents the value associated with the key in the data structure. If no
      * value is provided, it will default to `undefined`.
@@ -103,15 +102,15 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
      * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): NODE | undefined;
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V, count?: number): NODE | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function overrides the add method of a TypeScript class to add a new node to a data structure
      * and update the count.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-     * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which can be any type. It
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
+     * `keyOrNodeOrEntryOrRaw` parameter can accept a value of type `R`, which can be any type. It
      * can also accept a value of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
      * entry, or raw element
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
@@ -121,27 +120,27 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
      * be added once. However, you can specify a different value for `count` if you want to add
      * @returns a boolean value.
      */
-    add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
+    add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V, count?: number): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `delete` function in a binary tree data structure deletes a node based on its identifier and
-     * returns the deleted node along with the parent node that needs to be balanced.
-     * @param identifier - The identifier parameter is the value used to identify the node that needs to
-     * be deleted from the binary tree. It can be of any type and is the return type of the callback
-     * function.
-     * @param {C} callback - The `callback` parameter is a function that is used to determine the
-     * equality of nodes in the binary tree. It is optional and has a default value of
-     * `this._DEFAULT_CALLBACK`. The `callback` function takes a single argument, which is the identifier
-     * of a node, and returns a value that
-     * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
-     * being deleted. If set to true, the count of the node will not be considered and the node will be
-     * deleted regardless of its count. If set to false (default), the count of the node will be taken
-     * into account and the node
-     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
-     */
-    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
+     * The function overrides the delete method in a binary tree data structure, handling deletion of
+     * nodes and maintaining balance in the tree.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * parameter in the `delete` method is used to specify the condition for deleting a node from the
+     * binary tree. It can be a key, node, entry, or a custom predicate function that determines which
+     * node(s) should be deleted.
+     * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
+     * boolean flag that determines whether to ignore the count of the node being deleted. If
+     * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
+     * `ignoreCount` is set to
+     * @returns The `delete` method overrides the default delete behavior in a binary tree data
+     * structure. It takes a predicate or node to be deleted and an optional flag to ignore count. The
+     * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
+     * deleted node and whether balancing is needed in the tree.
+     */
+    delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -41,17 +41,17 @@ exports.AVLTreeMultiMapNode = AVLTreeMultiMapNode;
 class AVLTreeMultiMap extends avl_tree_1.AVLTree {
     /**
      * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
-     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the AVLTreeMultiMap. It can include properties such as `compareKeys` and
      * `compareValues` functions to define custom comparison logic for keys and values, respectively.
      */
-    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
+    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
         super([], options);
         this._count = 0;
-        if (keysOrNodesOrEntriesOrRawElements)
-            this.addMany(keysOrNodesOrEntriesOrRawElements);
+        if (keysOrNodesOrEntriesOrRaws)
+            this.addMany(keysOrNodesOrEntriesOrRaws);
     }
     /**
      * The function calculates the sum of the count property of all nodes in a tree using depth-first
@@ -96,23 +96,23 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * object.
      */
     createTree(options) {
-        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
+        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * The function checks if the input is an instance of AVLTreeMultiMapNode.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
      * an instance of the `AVLTreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement) {
-        return keyOrNodeOrEntryOrRawElement instanceof AVLTreeMultiMapNode;
+    isNode(keyOrNodeOrEntryOrRaw) {
+        return keyOrNodeOrEntryOrRaw instanceof AVLTreeMultiMapNode;
     }
     /**
      * The function `keyValueOrEntryOrRawElementToNode` converts a key, value, entry, or raw element into
      * a node object.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-     * `keyOrNodeOrEntryOrRawElement` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
+     * `keyOrNodeOrEntryOrRaw` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `override` function. It represents the value associated with the key in the data structure. If no
      * value is provided, it will default to `undefined`.
@@ -120,25 +120,25 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count = 1) {
-        if (keyOrNodeOrEntryOrRawElement === undefined || keyOrNodeOrEntryOrRawElement === null)
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count = 1) {
+        if (keyOrNodeOrEntryOrRaw === undefined || keyOrNodeOrEntryOrRaw === null)
             return;
-        if (this.isNode(keyOrNodeOrEntryOrRawElement))
-            return keyOrNodeOrEntryOrRawElement;
-        if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
-            const [key, entryValue] = keyOrNodeOrEntryOrRawElement;
+        if (this.isNode(keyOrNodeOrEntryOrRaw))
+            return keyOrNodeOrEntryOrRaw;
+        if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
+            const [key, entryValue] = keyOrNodeOrEntryOrRaw;
             if (key === undefined || key === null)
                 return;
             if (this.isKey(key))
                 return this.createNode(key, value !== null && value !== void 0 ? value : entryValue, count);
         }
-        if (this.toEntryFn) {
-            const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement);
+        if (this._toEntryFn) {
+            const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw);
             if (this.isKey(key))
                 return this.createNode(key, value !== null && value !== void 0 ? value : entryValue, count);
         }
-        if (this.isKey(keyOrNodeOrEntryOrRawElement))
-            return this.createNode(keyOrNodeOrEntryOrRawElement, value, count);
+        if (this.isKey(keyOrNodeOrEntryOrRaw))
+            return this.createNode(keyOrNodeOrEntryOrRaw, value, count);
         return;
     }
     /**
@@ -147,8 +147,8 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      *
      * The function overrides the add method of a TypeScript class to add a new node to a data structure
      * and update the count.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-     * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which can be any type. It
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
+     * `keyOrNodeOrEntryOrRaw` parameter can accept a value of type `R`, which can be any type. It
      * can also accept a value of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
      * entry, or raw element
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
@@ -158,8 +158,8 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * be added once. However, you can specify a different value for `count` if you want to add
      * @returns a boolean value.
      */
-    add(keyOrNodeOrEntryOrRawElement, value, count = 1) {
-        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count);
+    add(keyOrNodeOrEntryOrRaw, value, count = 1) {
+        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count);
         if (newNode === undefined)
             return false;
         const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
@@ -173,28 +173,27 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `delete` function in a binary tree data structure deletes a node based on its identifier and
-     * returns the deleted node along with the parent node that needs to be balanced.
-     * @param identifier - The identifier parameter is the value used to identify the node that needs to
-     * be deleted from the binary tree. It can be of any type and is the return type of the callback
-     * function.
-     * @param {C} callback - The `callback` parameter is a function that is used to determine the
-     * equality of nodes in the binary tree. It is optional and has a default value of
-     * `this._DEFAULT_CALLBACK`. The `callback` function takes a single argument, which is the identifier
-     * of a node, and returns a value that
-     * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
-     * being deleted. If set to true, the count of the node will not be considered and the node will be
-     * deleted regardless of its count. If set to false (default), the count of the node will be taken
-     * into account and the node
-     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
+     * The function overrides the delete method in a binary tree data structure, handling deletion of
+     * nodes and maintaining balance in the tree.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * parameter in the `delete` method is used to specify the condition for deleting a node from the
+     * binary tree. It can be a key, node, entry, or a custom predicate function that determines which
+     * node(s) should be deleted.
+     * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
+     * boolean flag that determines whether to ignore the count of the node being deleted. If
+     * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
+     * `ignoreCount` is set to
+     * @returns The `delete` method overrides the default delete behavior in a binary tree data
+     * structure. It takes a predicate or node to be deleted and an optional flag to ignore count. The
+     * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
+     * deleted node and whether balancing is needed in the tree.
      */
-    delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
+    delete(predicate, ignoreCount = false) {
         var _a;
         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;
+        const curr = (_a = this.getNode(predicate)) !== null && _a !== void 0 ? _a : undefined;
         if (!curr)
             return deletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : undefined;
@@ -236,7 +235,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
                     }
                 }
             }
-            this._size = this.size - 1;
+            this._size = this._size - 1;
             // TODO How to handle when the count of target node is lesser than current node's count
             if (orgCurrent)
                 this._count -= orgCurrent.count;

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

@@ -1,13 +1,12 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, BTNKeyOrNodeOrEntry } from '../../types';
-import { BTNEntry } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, BTNPredicate, BTNEntry } 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> {
     /**
@@ -45,7 +44,7 @@ export declare class AVLTree<K = any, V = any, R = BTNEntry<K, V>, NODE extends
     /**
      * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
      * entries, or raw elements.
-     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements. These elements will
      * be used to initialize the AVLTree.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
@@ -53,7 +52,7 @@ export declare class AVLTree<K = any, V = any, R = BTNEntry<K, V>, NODE extends
      * keys), `allowDuplicates` (a boolean indicating whether duplicate keys are allowed), and
      * `nodeBuilder` (
      */
-    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: AVLTreeOptions<K, V, R>);
+    constructor(keysOrNodesOrEntriesOrRaws?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: AVLTreeOptions<K, V, R>);
     /**
      * The function creates a new AVL tree node with the given key and value.
      * @param {K} key - The key parameter is of type K, which represents the key of the node being
@@ -74,40 +73,40 @@ export declare class AVLTree<K = any, V = any, R = BTNEntry<K, V>, NODE extends
     createTree(options?: AVLTreeOptions<K, V, R>): TREE;
     /**
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
      * an instance of the `AVLTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
+    isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept values of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can accept values of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
      * `RawElement`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key or node being added to the data structure.
      * @returns The method is returning a boolean value.
      */
-    add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
+    add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function overrides the delete method of a binary tree class and performs additional operations
-     * to balance the tree after deletion.
-     * @param identifier - The `identifier` parameter is the value or condition used to identify the
-     * node(s) to be deleted from the binary tree. It can be of any type that is compatible with the
-     * binary tree's node type.
-     * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
-     * node should be deleted or not. It is optional and has a default value of `this._DEFAULT_CALLBACK`.
-     * @returns The method is returning an array of BinaryTreeDeleteResult<NODE> objects.
+     * The function overrides the delete method in a TypeScript class, performs deletion, and then
+     * balances the tree if necessary.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * parameter in the `override delete` method can be one of the following types:
+     * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
+     * method from the superclass (presumably a parent class) with the provided `predicate`, which could
+     * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
+     * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
      */
-    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback?: C): BinaryTreeDeleteResult<NODE>[];
+    delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -180,10 +179,10 @@ export declare class AVLTree<K = any, V = any, R = BTNEntry<K, V>, NODE extends
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The `node` parameter can be of type `R` or
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} node - The `node` parameter can be of type `R` or
      * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      */
-    protected _balancePath(node: R | BTNKeyOrNodeOrEntry<K, V, NODE>): void;
+    protected _balancePath(node: BTNKeyOrNodeOrEntry<K, V, NODE> | R): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)