data-structure-typed 1.49.0 → 1.49.1

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNodeExemplar } from '../../types';
-import { BSTVariant, BTNodeKeyOrNode, CP, IterationType } from '../../types';
+import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNExemplar, BTNKeyOrNode } from '../../types';
+import { BSTVariant, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, N> {
@@ -46,12 +46,12 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
      * the tree with optional elements and options.
-     * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+     * @param [elements] - An optional iterable of BTNExemplar objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<BSTOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<BSTOptions<K>>);
     protected _root?: N;
     get root(): N | undefined;
     protected _variant: BSTVariant;
@@ -75,19 +75,19 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
     createTree(options?: Partial<BSTOptions<K>>): TREE;
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
-    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node.
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -104,7 +104,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
      * node was not added.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(k) - Additional space is required for the sorted array.
@@ -129,7 +129,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * `this.iterationType`, which suggests that it is a property of the current object.
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
     /**
      * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(n) - Additional space is required for the sorted array.
@@ -149,7 +149,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot?: BSTNodeKeyOrNode<K, N>): K | undefined;
+    lastKey(beginRoot?: BSTNKeyOrNode<K, N>): K | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -175,7 +175,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -189,7 +189,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNode(key: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | undefined;
+    ensureNode(key: BSTNKeyOrNode<K, N>, iterationType?: IterationType): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -213,7 +213,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNKeyOrNode<K, N>, iterationType?: IterationType): N[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -239,7 +239,7 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNKeyOrNode<K, N>, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.

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

@@ -57,7 +57,7 @@ export class BST extends BinaryTree {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
      * the tree with optional elements and options.
-     * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+     * @param [elements] - An optional iterable of BTNExemplar objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
@@ -108,7 +108,7 @@ export class BST extends BinaryTree {
     }
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
     isNode(exemplar) {
@@ -117,7 +117,7 @@ export class BST extends BinaryTree {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node.
      * @returns a node of type N or undefined.

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNodeExemplar, BTNodeKeyOrNode, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import { BinaryTreeDeleteResult, BTNCallback, BTNExemplar, BTNKeyOrNode, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
@@ -24,7 +24,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -32,7 +32,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
     protected _root: N;
     get root(): N;
     protected _size: number;
@@ -60,27 +60,27 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     createTree(options?: RBTreeOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
     /**
      * The function "isNotNodeInstance" checks if a potential key is a K.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -97,7 +97,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * being added to the binary search tree.
      * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
+    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -115,9 +115,9 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BiTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeleteResult<N>[];
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)

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

@@ -7,7 +7,6 @@
  */
 import { RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
-import { BinaryTreeNode } from './binary-tree';
 export class RedBlackTreeNode extends BSTNode {
     color;
     constructor(key, value, color = RBTNColor.BLACK) {
@@ -27,7 +26,7 @@ export class RedBlackTree extends BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -79,7 +78,7 @@ export class RedBlackTree extends BST {
     }
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
@@ -97,7 +96,7 @@ export class RedBlackTree extends BST {
     }
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
@@ -208,7 +207,7 @@ export class RedBlackTree extends BST {
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
         const ans = [];
@@ -303,7 +302,7 @@ export class RedBlackTree extends BST {
      * @returns a value of type `N`, `null`, or `undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        if (identifier instanceof BinaryTreeNode)
+        if (identifier instanceof RedBlackTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNode(beginRoot);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, BTNodeKeyOrNode, IterationType, TreeMultimapNested } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, BTNExemplar, BTNKeyOrNode, TreeMultimapNested, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
+import { IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, N> {
@@ -27,7 +27,7 @@ export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNo
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>> extends AVLTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
-    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
+    constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
     private _count;
     get count(): number;
     /**
@@ -43,21 +43,21 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
     createTree(options?: TreeMultimapOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
     /**
      * The function "isNotNodeInstance" checks if a potential key is a K.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
+    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -66,7 +66,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * times the value should be added to the node. If not provided, it defaults to 1.
      * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | undefined;
+    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V, count?: number): N | undefined;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -87,7 +87,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns The method is returning either the newly inserted node or `undefined` if the insertion
      * was not successful.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | undefined;
+    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | undefined;
     /**
      * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -102,7 +102,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * either keys, nodes, or entries.
      * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNExemplar<K, V, N>>): (N | undefined)[];
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
@@ -140,9 +140,9 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * 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
      * decremented by 1 and
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BiTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeleteResult<N>[];
     /**
      * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
      * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
@@ -178,7 +178,7 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
      * added, or `undefined` if no node was added.
      */
-    protected _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<K, N>): N | undefined;
+    protected _addTo(newNode: N | undefined, parent: BSTNKeyOrNode<K, N>): N | undefined;
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
      * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
@@ -188,6 +188,6 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    protected _swapProperties(srcNode: BSTNodeKeyOrNode<K, N>, destNode: BSTNodeKeyOrNode<K, N>): N | undefined;
+    protected _swapProperties(srcNode: BSTNKeyOrNode<K, N>, destNode: BSTNKeyOrNode<K, N>): N | undefined;
     protected _replaceNode(oldNode: N, newNode: N): N;
 }

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

@@ -53,7 +53,7 @@ export class TreeMultimap extends AVLTree {
     }
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
@@ -71,7 +71,7 @@ export class TreeMultimap extends AVLTree {
     }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it
+     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -225,7 +225,7 @@ export class TreeMultimap extends AVLTree {
      * 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
      * decremented by 1 and
-     * @returns an array of `BiTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<N>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
         const deletedResult = [];

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

@@ -1,7 +1,13 @@
-import type { DijkstraResult, VertexKey } from '../../types';
-import { EntryCallback } from "../../types";
-import { IGraph } from '../../interfaces';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { DijkstraResult, EntryCallback, VertexKey } from '../../types';
 import { IterableEntryBase } from "../base";
+import { IGraph } from '../../interfaces';
 export declare abstract class AbstractVertex<V = any> {
     key: VertexKey;
     value: V | undefined;

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

@@ -1,14 +1,7 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 import { uuidV4 } from '../../utils';
-import { PriorityQueue } from '../priority-queue';
-import { Queue } from '../queue';
 import { IterableEntryBase } from "../base";
+import { Heap } from '../heap';
+import { Queue } from '../queue';
 export class AbstractVertex {
     key;
     value;
@@ -438,13 +431,7 @@ export class AbstractGraph extends IterableEntryBase {
      * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstraWithoutHeap(src, dest, getMinDist, genPaths) {
-        if (getMinDist === undefined)
-            getMinDist = false;
-        if (genPaths === undefined)
-            genPaths = false;
-        if (dest === undefined)
-            dest = undefined;
+    dijkstraWithoutHeap(src, dest = undefined, getMinDist = false, genPaths = false) {
         let minDist = Infinity;
         let minDest = undefined;
         let minPath = [];
@@ -573,13 +560,7 @@ export class AbstractGraph extends IterableEntryBase {
      * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstra(src, dest, getMinDist, genPaths) {
-        if (getMinDist === undefined)
-            getMinDist = false;
-        if (genPaths === undefined)
-            genPaths = false;
-        if (dest === undefined)
-            dest = undefined;
+    dijkstra(src, dest = undefined, getMinDist = false, genPaths = false) {
         let minDist = Infinity;
         let minDest = undefined;
         let minPath = [];
@@ -597,7 +578,7 @@ export class AbstractGraph extends IterableEntryBase {
             if (vertexOrKey instanceof AbstractVertex)
                 distMap.set(vertexOrKey, Infinity);
         }
-        const heap = new PriorityQueue([], { comparator: (a, b) => a.key - b.key });
+        const heap = new Heap([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, undefined);
@@ -964,13 +945,28 @@ export class AbstractGraph extends IterableEntryBase {
         }
         const cycles = new Map();
         if (needCycles) {
-            let SCCs = new Map();
-            if (SCCs.size < 1) {
-                SCCs = getSCCs();
-            }
-            SCCs.forEach((SCC, low) => {
-                if (SCC.length > 1) {
-                    cycles.set(low, SCC);
+            const visitedMap = new Map();
+            const stack = [];
+            const findCyclesDFS = (cur, parent) => {
+                visitedMap.set(cur, true);
+                stack.push(cur);
+                const neighbors = this.getNeighbors(cur);
+                for (const neighbor of neighbors) {
+                    if (!visitedMap.get(neighbor)) {
+                        findCyclesDFS(neighbor, cur);
+                    }
+                    else if (stack.includes(neighbor) && neighbor !== parent) {
+                        const cycleStartIndex = stack.indexOf(neighbor);
+                        const cycle = stack.slice(cycleStartIndex);
+                        const cycleLow = Math.min(...cycle.map(v => dfnMap.get(v) || Infinity));
+                        cycles.set(cycleLow, cycle);
+                    }
+                }
+                stack.pop();
+            };
+            vertexMap.forEach(v => {
+                if (!visitedMap.get(v)) {
+                    findCyclesDFS(v, undefined);
                 }
             });
         }

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

@@ -1,5 +1,12 @@
-import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 import type { VertexKey } from '../../types';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import { IGraph } from '../../interfaces';
 export declare class DirectedVertex<V = any> extends AbstractVertex<V> {
     /**

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

@@ -1,12 +1,5 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { arrayRemove } from '../../utils';
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+import { arrayRemove } from '../../utils';
 export class DirectedVertex extends AbstractVertex {
     /**
      * The constructor function initializes a vertex with an optional value.

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

@@ -1,4 +1,4 @@
-import { MapGraphCoordinate, VertexKey } from '../../types';
+import type { MapGraphCoordinate, VertexKey } from '../../types';
 import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
 export declare class MapVertex<V = any> extends DirectedVertex<V> {
     lat: number;

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

@@ -1,6 +1,13 @@
-import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 import type { VertexKey } from '../../types';
 import { IGraph } from '../../interfaces';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     /**
      * The constructor function initializes a vertex with an optional value.

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

@@ -1,12 +1,5 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { arrayRemove } from '../../utils';
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+import { arrayRemove } from '../../utils';
 export class UndirectedVertex extends AbstractVertex {
     /**
      * The constructor function initializes a vertex with an optional value.

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

@@ -5,8 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
-import { IterableEntryBase } from "../base";
+import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import { IterableEntryBase } from '../base';
+/**
+ * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete elements based on a key.
+ * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
+ * 4. Unordered Collection: HashMap does not guarantee the order of elements, and the order may change over time.
+ */
 export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _store: {
         [key: string]: HashMapStoreItem<K, V>;
@@ -117,6 +123,11 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _isObjKey(key: any): key is (object | ((...args: any[]) => any));
     protected _getNoObjKey(key: K): string;
 }
+/**
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which elements are inserted. Therefore, when you traverse it, elements will be returned in the order they were inserted into the map.
+ * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of elements through the linked list.
+ * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
+ */
 export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
     protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
@@ -169,6 +180,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     set(key: K, value?: V): number;
     has(key: K): boolean;
+    hasValue(value: V): boolean;
     setMany(entries: Iterable<[K, V]>): void;
     /**
      * Time Complexity: O(1)