deque-typed 1.54.1 → 1.54.3

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

@@ -5,10 +5,11 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback, IterationType, OptNodeOrNull, RBTNColor, TreeCounterOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, EntryCallback, IterationType, RBTNColor, TreeCounterOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 export declare class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
+    parent?: TreeCounterNode<K, V>;
     /**
      * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
      * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -22,13 +23,12 @@ export declare class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<
      * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
      */
     constructor(key: K, value?: V, count?: number, color?: RBTNColor);
-    parent?: TreeCounterNode<K, V>;
-    _left?: OptNodeOrNull<TreeCounterNode<K, V>>;
-    get left(): OptNodeOrNull<TreeCounterNode<K, V>>;
-    set left(v: OptNodeOrNull<TreeCounterNode<K, V>>);
-    _right?: OptNodeOrNull<TreeCounterNode<K, V>>;
-    get right(): OptNodeOrNull<TreeCounterNode<K, V>>;
-    set right(v: OptNodeOrNull<TreeCounterNode<K, V>>);
+    _left?: TreeCounterNode<K, V> | null | undefined;
+    get left(): TreeCounterNode<K, V> | null | undefined;
+    set left(v: TreeCounterNode<K, V> | null | undefined);
+    _right?: TreeCounterNode<K, V> | null | undefined;
+    get right(): TreeCounterNode<K, V> | null | undefined;
+    set right(v: TreeCounterNode<K, V> | null | undefined);
 }
 /**
  *
@@ -43,7 +43,7 @@ export declare class TreeCounter<K = any, V = any, R = object, MK = any, MV = an
      * behavior of the `TreeCounter` constructor. It can include properties such as `compareKeys` and
      * `compareValues`, which are functions used to compare keys and values respectively.
      */
-    constructor(keysNodesEntriesOrRaws?: Iterable<BTNRep<K, V, TreeCounterNode<K, V>> | R>, options?: TreeCounterOptions<K, V, R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: TreeCounterOptions<K, V, R>);
     protected _count: number;
     /**
      * The function calculates the sum of the count property of all nodes in a tree structure.
@@ -84,19 +84,19 @@ export declare class TreeCounter<K = any, V = any, R = object, MK = any, MV = an
     createTree(options?: TreeCounterOptions<K, V, R>): TreeCounter<K, V, R, MK, MV, MR>;
     /**
      * The function checks if the input is an instance of the TreeCounterNode class.
-     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `TreeCounterNode` class.
      */
-    isNode(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>): keyNodeOrEntry is TreeCounterNode<K, V>;
+    isNode(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is TreeCounterNode<K, V>;
     /**
      * 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 {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
      * `keyNodeOrEntry` 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.
@@ -106,14 +106,14 @@ export declare class TreeCounter<K = any, V = any, R = object, MK = any, MV = an
      * @returns The method is returning a boolean value. It returns true if the addition of the new node
      * was successful, and false otherwise.
      */
-    add(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>, value?: V, count?: number): boolean;
+    add(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * 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 {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - 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, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
@@ -122,7 +122,7 @@ export declare class TreeCounter<K = any, V = any, R = object, MK = any, MV = an
      * `ignoreCount` is `false
      * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<TreeCounterNode<K, V>>` objects.
      */
-    delete(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>, ignoreCount?: boolean): BinaryTreeDeleteResult<TreeCounterNode<K, V>>[];
+    delete(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, ignoreCount?: boolean): BinaryTreeDeleteResult<TreeCounterNode<K, V>>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -172,8 +172,8 @@ export declare class TreeCounter<K = any, V = any, R = object, MK = any, MV = an
     /**
      * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @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.
@@ -181,7 +181,7 @@ export declare class TreeCounter<K = any, V = any, R = object, MK = any, MV = an
      * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
      * @returns either a TreeCounterNode<K, V> object or undefined.
      */
-    protected _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>, value?: V, count?: number): [TreeCounterNode<K, V> | undefined, V | undefined];
+    protected _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): [TreeCounterNode<K, V> | undefined, V | undefined];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -79,7 +79,7 @@ class TreeCounter extends red_black_tree_1.RedBlackTree {
      */
     getComputedCount() {
         let sum = 0;
-        this.dfs(node => (sum += node.count));
+        this.dfs(node => (sum += node ? node.count : 0));
         return sum;
     }
     /**
@@ -111,8 +111,8 @@ class TreeCounter extends red_black_tree_1.RedBlackTree {
     }
     /**
      * The function checks if the input is an instance of the TreeCounterNode class.
-     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `TreeCounterNode` class.
      */
@@ -125,7 +125,7 @@ class TreeCounter extends red_black_tree_1.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 {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
      * `keyNodeOrEntry` 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.
@@ -153,7 +153,7 @@ class TreeCounter extends red_black_tree_1.RedBlackTree {
      *
      * 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 {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - 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, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
@@ -294,9 +294,9 @@ class TreeCounter extends red_black_tree_1.RedBlackTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                if (this._isMapMode)
+                if (this._isMapMode && midNode !== null)
                     this.add(midNode.key, undefined, midNode.count);
-                else
+                else if (midNode !== null)
                     this.add(midNode.key, midNode.value, midNode.count);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
@@ -313,9 +313,9 @@ class TreeCounter extends red_black_tree_1.RedBlackTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        if (this._isMapMode)
+                        if (this._isMapMode && midNode !== null)
                             this.add(midNode.key, undefined, midNode.count);
-                        else
+                        else if (midNode !== null)
                             this.add(midNode.key, midNode.value, midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -334,7 +334,7 @@ class TreeCounter extends red_black_tree_1.RedBlackTree {
      */
     clone() {
         const cloned = this.createTree();
-        this.bfs(node => cloned.add(node.key, undefined, node.count));
+        this.bfs(node => cloned.add(node === null ? null : node.key, undefined, node === null ? 0 : node.count));
         if (this._isMapMode)
             cloned._store = this._store;
         return cloned;
@@ -365,8 +365,8 @@ class TreeCounter extends red_black_tree_1.RedBlackTree {
     /**
      * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
      * @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.

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

@@ -5,10 +5,11 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BTNRep, OptNodeOrNull, TreeMultiMapOptions } from '../../types';
+import type { TreeMultiMapOptions } from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
+    parent?: TreeMultiMapNode<K, V>;
     /**
      * This TypeScript constructor initializes an object with a key of type K and an array of values of
      * type V.
@@ -19,21 +20,20 @@ export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode
      * type `V`.
      */
     constructor(key: K, value: V[]);
-    parent?: TreeMultiMapNode<K, V>;
-    _left?: OptNodeOrNull<TreeMultiMapNode<K, V>>;
-    get left(): OptNodeOrNull<TreeMultiMapNode<K, V>>;
-    set left(v: OptNodeOrNull<TreeMultiMapNode<K, V>>);
-    _right?: OptNodeOrNull<TreeMultiMapNode<K, V>>;
-    get right(): OptNodeOrNull<TreeMultiMapNode<K, V>>;
-    set right(v: OptNodeOrNull<TreeMultiMapNode<K, V>>);
+    _left?: TreeMultiMapNode<K, V> | null | undefined;
+    get left(): TreeMultiMapNode<K, V> | null | undefined;
+    set left(v: TreeMultiMapNode<K, V> | null | undefined);
+    _right?: TreeMultiMapNode<K, V> | null | undefined;
+    get right(): TreeMultiMapNode<K, V> | null | undefined;
+    set right(v: TreeMultiMapNode<K, V> | null | undefined);
 }
 /**
  *
  * @example
  * // Find elements in a range
  *     const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(tmm.search(new Range(5, 10))); // [5, 10, 7]
- *     console.log(tmm.search(new Range(4, 12))); // [5, 10, 12, 7]
+ *     console.log(tmm.search(new Range(5, 10))); // [5, 7, 10]
+ *     console.log(tmm.search(new Range(4, 12))); // [5, 7, 10, 12]
  *     console.log(tmm.search(new Range(15, 20))); // [15, 18]
  */
 export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends RedBlackTree<K, V[], R, MK, MV[], MR> implements IBinaryTree<K, V[], R, MK, MV, MR> {
@@ -48,7 +48,7 @@ export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = a
      * `TreeMultiMapOptions<K, V[], R>`. It is an optional parameter that allows you to specify
      * additional options for configuring the TreeMultiMap instance.
      */
-    constructor(keysNodesEntriesOrRaws?: Iterable<BTNRep<K, V[], TreeMultiMapNode<K, V>> | R>, options?: TreeMultiMapOptions<K, V[], R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R>, options?: TreeMultiMapOptions<K, V[], R>);
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -75,7 +75,7 @@ export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = a
      * an empty array as its value.
      */
     createNode(key: K): TreeMultiMapNode<K, V>;
-    add(node: BTNRep<K, V[], TreeMultiMapNode<K, V>>): boolean;
+    add(node: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
     add(key: K, value: V): boolean;
     /**
      * Time Complexity: O(log n)
@@ -83,7 +83,7 @@ export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = a
      *
      * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
      * and deletes the entire node if no values are left for that key.
-     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
      * array of values, or just a key itself.
      * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
@@ -93,7 +93,7 @@ export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = a
      * @returns The `deleteValue` function returns a boolean value - `true` if the specified `value` was
      * successfully deleted from the values associated with the `keyNodeOrEntry`, and `false` otherwise.
      */
-    deleteValue(keyNodeOrEntry: BTNRep<K, V[], TreeMultiMapNode<K, V>> | K, value: V): boolean;
+    deleteValue(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined, value: V): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -43,8 +43,8 @@ exports.TreeMultiMapNode = TreeMultiMapNode;
  * @example
  * // Find elements in a range
  *     const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(tmm.search(new Range(5, 10))); // [5, 10, 7]
- *     console.log(tmm.search(new Range(4, 12))); // [5, 10, 12, 7]
+ *     console.log(tmm.search(new Range(5, 10))); // [5, 7, 10]
+ *     console.log(tmm.search(new Range(4, 12))); // [5, 7, 10, 12]
  *     console.log(tmm.search(new Range(15, 20))); // [15, 18]
  */
 class TreeMultiMap extends red_black_tree_1.RedBlackTree {
@@ -101,7 +101,7 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      *
      * The function `add` in TypeScript overrides the superclass method to add key-value pairs to a
      * TreeMultiMapNode, handling different input types and scenarios.
-     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `override add` method can be either a `BTNRep` object containing a key, an array
      * of values, and a `TreeMultiMapNode`, or just a key.
      * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
@@ -153,7 +153,7 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      *
      * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
      * and deletes the entire node if no values are left for that key.
-     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
      * array of values, or just a key itself.
      * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific

package/dist/index.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
  */
 export * from './data-structures/queue/deque';

package/dist/index.js

@@ -17,11 +17,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * 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 { Deque, ObjectDeque, ArrayDeque } from 'data-structure-typed';
 __exportStar(require("./data-structures/queue/deque"), exports);
 __exportStar(require("./types/data-structures/queue/deque"), exports);
 __exportStar(require("./types/common"), exports);

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

@@ -5,6 +5,7 @@ export type BinaryTreeOptions<K, V, R> = {
     iterationType?: IterationType;
     toEntryFn?: ToEntryFn<K, V, R>;
     isMapMode?: boolean;
+    isDuplicate?: boolean;
 };
 export type BinaryTreePrintOptions = {
     isShowUndefined?: boolean;

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

@@ -1,7 +1,7 @@
 import type { BinaryTreeOptions } from './binary-tree';
 import { Comparable } from '../../utils';
 import { OptValue } from '../../common';
-export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
+export type BSTOptions<K, V, R> = Omit<BinaryTreeOptions<K, V, R>, 'isDuplicate'> & {
     specifyComparable?: (key: K) => Comparable;
     isReverse?: boolean;
 };

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

@@ -3,7 +3,7 @@ export * from './bst';
 export * from './avl-tree';
 export * from './segment-tree';
 export * from './avl-tree-multi-map';
-export * from './rb-tree';
+export * from './red-black-tree';
 export * from './tree-multi-map';
 export * from './tree-counter';
 export * from './avl-tree-counter';

package/dist/types/data-structures/binary-tree/index.js

@@ -19,7 +19,7 @@ __exportStar(require("./bst"), exports);
 __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./segment-tree"), exports);
 __exportStar(require("./avl-tree-multi-map"), exports);
-__exportStar(require("./rb-tree"), exports);
+__exportStar(require("./red-black-tree"), exports);
 __exportStar(require("./tree-multi-map"), exports);
 __exportStar(require("./tree-counter"), exports);
 __exportStar(require("./avl-tree-counter"), exports);

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

@@ -1,2 +1,2 @@
-import type { RedBlackTreeOptions } from './rb-tree';
+import type { RedBlackTreeOptions } from './red-black-tree';
 export type TreeCounterOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

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

@@ -1,2 +1,2 @@
-import type { RedBlackTreeOptions } from './rb-tree';
+import type { RedBlackTreeOptions } from './red-black-tree';
 export type TreeMultiMapOptions<K, V, R> = Omit<RedBlackTreeOptions<K, V, R>, 'isMapMode'> & {};

package/dist/utils/utils.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 { Comparable, Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from '../types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deque-typed",
-  "version": "1.54.1",
+  "version": "1.54.3",
   "description": "Deque. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -95,7 +95,7 @@
     "documentation",
     "visualization"
   ],
-  "author": "Tyler Zeng zrwusa@gmail.com",
+  "author": "Pablo Zeng zrwusa@gmail.com",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/zrwusa/data-structure-typed/issues"
@@ -119,6 +119,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.54.1"
+    "data-structure-typed": "^1.54.3"
   }
 }

package/src/data-structures/binary-tree/avl-tree-counter.ts

@@ -9,15 +9,15 @@ import type {
   AVLTreeCounterOptions,
   BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
-  BTNRep,
   EntryCallback,
-  IterationType,
-  OptNodeOrNull
+  IterationType
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
 export class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K, V> {
+  override parent?: AVLTreeCounterNode<K, V> = undefined;
+
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
    * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -33,28 +33,26 @@ export class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K, V> {
     this.count = count;
   }
 
-  override parent?: AVLTreeCounterNode<K, V> = undefined;
-
-  override _left?: OptNodeOrNull<AVLTreeCounterNode<K, V>> = undefined;
+  override _left?: AVLTreeCounterNode<K, V> | null | undefined = undefined;
 
-  override get left(): OptNodeOrNull<AVLTreeCounterNode<K, V>> {
+  override get left(): AVLTreeCounterNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<AVLTreeCounterNode<K, V>>) {
+  override set left(v: AVLTreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<AVLTreeCounterNode<K, V>> = undefined;
+  override _right?: AVLTreeCounterNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<AVLTreeCounterNode<K, V>> {
+  override get right(): AVLTreeCounterNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<AVLTreeCounterNode<K, V>>) {
+  override set right(v: AVLTreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -78,7 +76,9 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * `compareValues` functions to define custom comparison logic for keys and values, respectively.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, AVLTreeCounterNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: AVLTreeCounterOptions<K, V, R>
   ) {
     super([], options);
@@ -145,12 +145,14 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
 
   /**
    * The function checks if the input is an instance of AVLTreeCounterNode.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `AVLTreeCounterNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>): keyNodeOrEntry is AVLTreeCounterNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is AVLTreeCounterNode<K, V> {
     return keyNodeOrEntry instanceof AVLTreeCounterNode;
   }
 
@@ -160,9 +162,9 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    *
    * The function overrides the add method of a TypeScript class to add a new node to a data structure
    * and update the count.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
    * `keyNodeOrEntry` parameter can accept a value of type `R`, which can be any type. It
-   * can also accept a value of type `BTNRep<K, V, AVLTreeCounterNode<K, V>>`, which represents a key, node,
+   * can also accept a value of type `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`, which represents a key, node,
    * entry, or raw element
    * @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.
@@ -171,7 +173,11 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * be added once. However, you can specify a different value for `count` if you want to add
    * @returns a boolean value.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>, value?: V, count = 1): boolean {
+  override add(
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V,
+    count = 1
+  ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     if (newNode === undefined) return false;
 
@@ -189,7 +195,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    *
    * The function overrides the delete method in a binary tree data structure, handling deletion of
    * nodes and maintaining balance in the tree.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - 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, or entry that determines which
    * node(s) should be deleted.
@@ -203,7 +209,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * deleted node and whether balancing is needed in the tree.
    */
   override delete(
-    keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     ignoreCount = false
   ): BinaryTreeDeleteResult<AVLTreeCounterNode<K, V>>[] {
     const deletedResult: BinaryTreeDeleteResult<AVLTreeCounterNode<K, V>>[] = [];
@@ -276,6 +282,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
   /**
    * Time Complexity: O(n log n)
    * Space Complexity: O(log n)
+   *
    * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
    * tree using either a recursive or iterative approach.
    * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
@@ -374,8 +381,8 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
   /**
    * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
    * a node object.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
-   * `keyNodeOrEntry` parameter can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
+   * `keyNodeOrEntry` parameter can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @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`.
@@ -384,7 +391,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * @returns either a AVLTreeCounterNode<K, V> object or undefined.
    */
   protected override _keyValueNodeOrEntryToNodeAndValue(
-    keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
   ): [AVLTreeCounterNode<K, V> | undefined, V | undefined] {