data-structure-typed 1.52.5 → 1.52.7

package/dist/mjs/data-structures/binary-tree/rb-tree.js

@@ -34,7 +34,7 @@ export class RedBlackTreeNode extends BSTNode {
 export class RedBlackTree extends BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-     * @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. It is used to
      * initialize the RBTree with the provided elements.
      * @param [options] - The `options` parameter is an optional object that can be passed to the
@@ -42,11 +42,11 @@ export class RedBlackTree extends BST {
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
      * depend on the implementation
      */
-    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
+    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
         super([], options);
         this._root = this.NIL;
-        if (keysOrNodesOrEntriesOrRawElements) {
-            this.addMany(keysOrNodesOrEntriesOrRawElements);
+        if (keysOrNodesOrEntriesOrRaws) {
+            this.addMany(keysOrNodesOrEntriesOrRaws);
         }
     }
     _root;
@@ -83,6 +83,8 @@ export class RedBlackTree extends BST {
     createTree(options) {
         return new RedBlackTree([], {
             iterationType: this.iterationType,
+            comparator: this._comparator,
+            toEntryFn: this._toEntryFn,
             ...options
         });
     }
@@ -91,13 +93,13 @@ export class RedBlackTree extends BST {
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @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 `RedBlackTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement) {
-        return keyOrNodeOrEntryOrRawElement instanceof RedBlackTreeNode;
+    isNode(keyOrNodeOrEntryOrRaw) {
+        return keyOrNodeOrEntryOrRaw instanceof RedBlackTreeNode;
     }
     // /**
     //  * Time Complexity: O(1)
@@ -110,27 +112,27 @@ export class RedBlackTree extends BST {
     //  *
     //  * The function `keyValueOrEntryOrRawElementToNode` takes a key, value, or entry and returns a node if it is
     //  * valid, otherwise it returns undefined.
-    //  * @param {BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The key, value, or entry to convert.
-    //  * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntryOrRawElement` is a key).
+    //  * @param {BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRaw - The key, value, or entry to convert.
+    //  * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntryOrRaw` is a key).
     //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
     //  */
-    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
+    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): NODE | undefined {
     //
-    //   if (keyOrNodeOrEntryOrRawElement === null || keyOrNodeOrEntryOrRawElement === undefined) return;
-    //   if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
+    //   if (keyOrNodeOrEntryOrRaw === null || keyOrNodeOrEntryOrRaw === undefined) return;
+    //   if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
     //
-    //   if (this.toEntryFn) {
-    //     const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement as R);
+    //   if (this._toEntryFn) {
+    //     const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw as R);
     //     if (this.isKey(key)) return this.createNode(key, entryValue ?? value, 'RED');
     //   }
     //
-    //   if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
-    //     const [key, value] = keyOrNodeOrEntryOrRawElement;
+    //   if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
+    //     const [key, value] = keyOrNodeOrEntryOrRaw;
     //     if (key === undefined || key === null) return;
     //     else return  this.createNode(key, value, 'RED');
     //   }
     //
-    //   if (this.isKey(keyOrNodeOrEntryOrRawElement)) return this.createNode(keyOrNodeOrEntryOrRawElement, value, 'RED');
+    //   if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, 'RED');
     //
     //   return ;
     // }
@@ -151,8 +153,8 @@ export class RedBlackTree extends BST {
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key in the data structure. It represents the value that you want to add or update in the data
      * structure.
@@ -160,8 +162,8 @@ export class RedBlackTree extends BST {
      * the method returns true. If the node already exists and its value is updated, the method also
      * returns true. If the node cannot be added or updated, the method returns false.
      */
-    add(keyOrNodeOrEntryOrRawElement, value) {
-        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value);
+    add(keyOrNodeOrEntryOrRaw, value) {
+        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
         if (!this.isRealNode(newNode))
             return false;
         const insertStatus = this._insert(newNode);
@@ -183,24 +185,25 @@ export class RedBlackTree extends BST {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function overrides the delete method of a binary tree data structure, allowing for the
-     * deletion of a node and maintaining the balance of the tree.
-     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * that identifies the node to be deleted from the binary tree. It can be of any type that is
-     * returned by the callback function `C`. It can also be `null` or `undefined` if there is no node to
-     * delete.
-     * @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 type of the `callback` parameter is `C`, which is a generic type
-     * that extends the `BTNCallback
-     * @returns an array of BinaryTreeDeleteResult<NODE> objects.
+     * The function overrides the delete method in a binary tree data structure to remove a node based on
+     * a given predicate and maintain the binary search tree properties.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * parameter in the `override delete` method is used to specify the condition or key based on which a
+     * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
+     * function that determines which node(s) should be deleted.
+     * @returns The `override delete` method is returning an array of `BinaryTreeDeleteResult<NODE>`
+     * objects. Each object in the array contains information about the deleted node and whether
+     * balancing is needed.
      */
-    delete(identifier, callback = this._DEFAULT_CALLBACK) {
-        if (identifier === null)
+    delete(predicate) {
+        if (predicate === null)
             return [];
         const results = [];
-        callback = this._ensureCallback(identifier, callback);
-        const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
+        let nodeToDelete;
+        if (this._isPredicated(predicate))
+            nodeToDelete = this.getNode(predicate);
+        else
+            nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
         if (!nodeToDelete) {
             return results;
         }

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

@@ -1,8 +1,8 @@
 /**
  * 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 { SegmentTreeNodeVal } from '../../types';

package/dist/mjs/data-structures/binary-tree/segment-tree.js

@@ -1,8 +1,8 @@
 /**
  * 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
  */
 export class SegmentTreeNode {

package/dist/mjs/data-structures/binary-tree/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 { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, BTNKeyOrNodeOrEntry, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
-import { BTNEntry } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, BTNPredicate, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions, BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
@@ -39,14 +38,14 @@ export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMa
 export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>> extends RedBlackTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
-     * @param keysOrNodesOrEntriesOrRawElements - The parameter `keysOrNodesOrEntriesOrRawElements` is an
+     * @param keysOrNodesOrEntriesOrRaws - The parameter `keysOrNodesOrEntriesOrRaws` is an
      * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
      * TreeMultiMap with initial data.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
      * `compareValues`, which are functions used to compare keys and values respectively.
      */
-    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: TreeMultiMapOptions<K, V, R>);
+    constructor(keysOrNodesOrEntriesOrRaws?: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: TreeMultiMapOptions<K, V, R>);
     protected _count: number;
     /**
      * The function calculates the sum of the count property of all nodes in a tree structure.
@@ -88,8 +87,8 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
     /**
      * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that represents the value
      * associated with the key in the node. It is used when creating a new node or updating the value of
      * an existing node.
@@ -97,23 +96,23 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * 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;
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @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 `TreeMultiMapNode` 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 adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-     * `keyOrNodeOrEntryOrRawElement` parameter can accept one of the following types:
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
+     * `keyOrNodeOrEntryOrRaw` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
@@ -122,26 +121,24 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * @returns The method is returning a boolean value. It returns true if the addition of the new node
      * was successful, and false otherwise.
      */
-    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 function `delete` is used to remove a node from a binary tree and fix the tree if necessary.
-     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value or
-     * key that is used to identify the node that needs to be deleted from the binary tree. It can be of
-     * any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
-     * the node to be deleted
-     * @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 is used to compare nodes when searching for a
-     * specific node or when performing other operations on the
-     * @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 taken into account when deleting
-     * it. If set to false, the count of the node will be decremented by 1 before deleting it.
-     * @returns an array of BinaryTreeDeleteResult<NODE> objects.
-     */
-    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback?: C, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
+     * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
+     * structure, handling cases where nodes have children 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 or key based on which a node
+     * should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
+     * function.
+     * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
+     * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
+     * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
+     * `ignoreCount` is `false
+     * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
+     */
+    delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -36,17 +36,17 @@ export class TreeMultiMapNode extends RedBlackTreeNode {
 export class TreeMultiMap extends RedBlackTree {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
-     * @param keysOrNodesOrEntriesOrRawElements - The parameter `keysOrNodesOrEntriesOrRawElements` is an
+     * @param keysOrNodesOrEntriesOrRaws - The parameter `keysOrNodesOrEntriesOrRaws` is an
      * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
      * TreeMultiMap with initial data.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
      * `compareValues`, which are functions used to compare keys and values respectively.
      */
-    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
+    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
         super([], options);
-        if (keysOrNodesOrEntriesOrRawElements)
-            this.addMany(keysOrNodesOrEntriesOrRawElements);
+        if (keysOrNodesOrEntriesOrRaws)
+            this.addMany(keysOrNodesOrEntriesOrRaws);
     }
     _count = 0;
     // TODO the _count is not accurate after nodes count modified
@@ -97,14 +97,16 @@ export class TreeMultiMap extends RedBlackTree {
     createTree(options) {
         return new TreeMultiMap([], {
             iterationType: this.iterationType,
+            comparator: this._comparator,
+            toEntryFn: this._toEntryFn,
             ...options
         });
     }
     /**
      * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that represents the value
      * associated with the key in the node. It is used when creating a new node or updating the value of
      * an existing node.
@@ -112,36 +114,36 @@ export class TreeMultiMap extends RedBlackTree {
      * 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 ?? entryValue, 'BLACK', 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 ?? entryValue, 'BLACK', count);
         }
-        if (this.isKey(keyOrNodeOrEntryOrRawElement))
-            return this.createNode(keyOrNodeOrEntryOrRawElement, value, 'BLACK', count);
+        if (this.isKey(keyOrNodeOrEntryOrRaw))
+            return this.createNode(keyOrNodeOrEntryOrRaw, value, 'BLACK', count);
         return;
     }
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @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 `TreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement) {
-        return keyOrNodeOrEntryOrRawElement instanceof TreeMultiMapNode;
+    isNode(keyOrNodeOrEntryOrRaw) {
+        return keyOrNodeOrEntryOrRaw instanceof TreeMultiMapNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -149,8 +151,8 @@ export class TreeMultiMap extends RedBlackTree {
      *
      * The function overrides the add method of a class and adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-     * `keyOrNodeOrEntryOrRawElement` parameter can accept one of the following types:
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
+     * `keyOrNodeOrEntryOrRaw` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
@@ -159,8 +161,8 @@ export class TreeMultiMap extends RedBlackTree {
      * @returns The method is returning a boolean value. It returns true if the addition of the new node
      * was successful, and false otherwise.
      */
-    add(keyOrNodeOrEntryOrRawElement, value, count = 1) {
-        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count);
+    add(keyOrNodeOrEntryOrRaw, value, count = 1) {
+        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count);
         const orgCount = newNode?.count || 0;
         const isSuccessAdded = super.add(newNode);
         if (isSuccessAdded) {
@@ -175,26 +177,27 @@ export class TreeMultiMap extends RedBlackTree {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `delete` is used to remove a node from a binary tree and fix the tree if necessary.
-     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value or
-     * key that is used to identify the node that needs to be deleted from the binary tree. It can be of
-     * any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
-     * the node to be deleted
-     * @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 is used to compare nodes when searching for a
-     * specific node or when performing other operations on the
-     * @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 taken into account when deleting
-     * it. If set to false, the count of the node will be decremented by 1 before deleting it.
-     * @returns an array of BinaryTreeDeleteResult<NODE> objects.
+     * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
+     * structure, handling cases where nodes have children 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 or key based on which a node
+     * should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
+     * function.
+     * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
+     * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
+     * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
+     * `ignoreCount` is `false
+     * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
      */
-    delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
-        if (identifier === null)
+    delete(predicate, ignoreCount = false) {
+        if (predicate === null)
             return [];
         const results = [];
-        callback = this._ensureCallback(identifier, callback);
-        const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
+        let nodeToDelete;
+        if (this._isPredicated(predicate))
+            nodeToDelete = this.getNode(predicate);
+        else
+            nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
         if (!nodeToDelete) {
             return results;
         }

package/dist/mjs/data-structures/graph/abstract-graph.d.ts

@@ -1,8 +1,8 @@
 /**
  * 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 { DijkstraResult, EntryCallback, VertexKey } from '../../types';

package/dist/mjs/data-structures/graph/abstract-graph.js

@@ -459,7 +459,7 @@ export class AbstractGraph extends IterableEntryBase {
                 }
             }
         }
-        getMinDist &&
+        if (getMinDist)
             distMap.forEach((d, v) => {
                 if (v !== srcVertex) {
                     if (d < minDist) {
@@ -469,7 +469,8 @@ export class AbstractGraph extends IterableEntryBase {
                     }
                 }
             });
-        genPaths && getPaths(minDest);
+        if (genPaths)
+            getPaths(minDest);
         return { distMap, preMap, seen, paths, minDist, minPath };
     }
     /**
@@ -641,7 +642,8 @@ export class AbstractGraph extends IterableEntryBase {
                     if (sWeight !== undefined && dWeight !== undefined) {
                         if (distMap.get(s) !== Infinity && sWeight + weight < dWeight) {
                             distMap.set(d, sWeight + weight);
-                            genPath && preMap.set(d, s);
+                            if (genPath)
+                                preMap.set(d, s);
                         }
                     }
                 }
@@ -765,7 +767,8 @@ export class AbstractGraph extends IterableEntryBase {
             visited.add(vertex);
             currentPath.push(vertex.key);
             for (const neighbor of this.getNeighbors(vertex)) {
-                neighbor && dfs(neighbor, currentPath, visited);
+                if (neighbor)
+                    dfs(neighbor, currentPath, visited);
             }
             visited.delete(vertex);
             currentPath.pop();

package/dist/mjs/data-structures/graph/directed-graph.d.ts

@@ -1,8 +1,8 @@
 /**
  * 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 { VertexKey } from '../../types';

package/dist/mjs/data-structures/graph/directed-graph.js

@@ -217,8 +217,10 @@ export class DirectedGraph extends AbstractGraph {
         if (v1 && v2) {
             const v1ToV2 = this.deleteEdgeSrcToDest(v1, v2);
             const v2ToV1 = this.deleteEdgeSrcToDest(v2, v1);
-            v1ToV2 && removed.push(v1ToV2);
-            v2ToV1 && removed.push(v2ToV1);
+            if (v1ToV2)
+                removed.push(v1ToV2);
+            if (v2ToV1)
+                removed.push(v2ToV1);
         }
         return removed;
     }

package/dist/mjs/data-structures/graph/undirected-graph.d.ts

@@ -1,8 +1,8 @@
 /**
  * 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 { VertexKey } from '../../types';

package/dist/mjs/data-structures/hash/hash-map.d.ts

@@ -1,8 +1,8 @@
 /**
  * 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 { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem, LinkedHashMapOptions } from '../../types';

package/dist/mjs/data-structures/hash/hash-map.js

@@ -86,7 +86,7 @@ export class HashMap extends IterableEntryBase {
      * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
     isEmpty() {
-        return this.size === 0;
+        return this._size === 0;
     }
     /**
      * The clear() function resets the state of an object by clearing its internal store, object map, and

package/dist/mjs/data-structures/heap/heap.js

@@ -577,7 +577,7 @@ export class FibonacciHeap {
      * @returns The top element or undefined if the heap is empty.
      */
     pop() {
-        if (this.size === 0)
+        if (this._size === 0)
             return undefined;
         const z = this.min;
         if (z.child) {
@@ -710,7 +710,7 @@ export class FibonacciHeap {
      * @protected
      */
     _consolidate() {
-        const A = new Array(this.size);
+        const A = new Array(this._size);
         const elements = this.consumeLinkedList(this.root);
         let x, y, d, t;
         for (const node of elements) {
@@ -729,7 +729,7 @@ export class FibonacciHeap {
             }
             A[d] = x;
         }
-        for (let i = 0; i < this.size; i++) {
+        for (let i = 0; i < this._size; i++) {
             if (A[i] && this.comparator(A[i].element, this.min.element) <= 0) {
                 this._min = A[i];
             }

package/dist/mjs/data-structures/linked-list/doubly-linked-list.d.ts

@@ -1,8 +1,8 @@
 /**
  * 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 { DoublyLinkedListOptions, ElementCallback } from '../../types';