deque-typed 1.52.0 → 1.52.2

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

@@ -19,7 +19,7 @@ class BSTNode extends binary_tree_1.BinaryTreeNode {
     }
     /**
      * The function sets the left child of a node and updates the parent reference of the child.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be an
+     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be an
      * instance of the `NODE` class or `undefined`.
      */
     set left(v) {
@@ -38,7 +38,7 @@ class BSTNode extends binary_tree_1.BinaryTreeNode {
     }
     /**
      * The function sets the right child of a node and updates the parent reference of the child.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be a
+     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be a
      * `NODE` object or `undefined`.
      */
     set right(v) {
@@ -119,8 +119,8 @@ class BST extends binary_tree_1.BinaryTree {
     }
     /**
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
-     * type R or KeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
+     * type R or BTNKeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
      * element.
      * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
      * value associated with a key in a key-value pair.
@@ -136,7 +136,7 @@ class BST extends binary_tree_1.BinaryTree {
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
      * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
@@ -151,8 +151,8 @@ class BST extends binary_tree_1.BinaryTree {
     }
     /**
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @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
      * an instance of the `BSTNode` class.
      */
@@ -164,8 +164,8 @@ class BST extends binary_tree_1.BinaryTree {
      * Space Complexity: O(1)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
@@ -329,7 +329,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param [onlyOne=false] - A boolean value indicating whether to return only the first matching node
      * or all matching nodes. If set to true, only the first matching node will be returned. If set to
      * false, all matching nodes will be returned. The default value is false.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the search in the binary tree. It can be either a node object, a key-value pair, or an
      * entry object. If it is not provided, the `root` of the binary tree is used as the starting point.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -462,7 +462,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -486,7 +486,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -510,7 +510,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
      * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -538,7 +538,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -683,8 +683,8 @@ class BST extends binary_tree_1.BinaryTree {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            const left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            const right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            const left = node.left ? ((_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1) : -1;
+                            const right = node.right ? ((_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1) : -1;
                             if (Math.abs(left - right) > 1)
                                 return false;
                             depths.set(node, 1 + Math.max(left, right));
@@ -713,7 +713,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
-     * @param {NODE | undefined} v - v is a parameter of type NODE or undefined.
+     * @param {OptBSTN<NODE>} v - v is a parameter of type NODE or undefined.
      */
     _setRoot(v) {
         if (v) {

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

@@ -1,4 +1,4 @@
-import type { BinaryTreeDeleteResult, BTNCallback, CRUD, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import type { BinaryTreeDeleteResult, BTNCallback, BTNKeyOrNodeOrEntry, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BTNEntry } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
@@ -38,7 +38,7 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
      * depend on the implementation
      */
-    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K, V, R>);
+    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K, V, R>);
     protected _root: NODE | undefined;
     /**
      * The function returns the root node of a tree or undefined if there is no root.
@@ -76,12 +76,12 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @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
      * an instance of the `RedBlackTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
+    isNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -104,8 +104,8 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` 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.
@@ -113,7 +113,7 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * 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: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
+    add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -94,8 +94,8 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @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
      * an instance of the `RedBlackTreeNode` class.
      */
@@ -113,11 +113,11 @@ class RedBlackTree extends bst_1.BST {
     //  *
     //  * The function `keyValueOrEntryOrRawElementToNode` takes a key, value, or entry and returns a node if it is
     //  * valid, otherwise it returns undefined.
-    //  * @param {KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The key, value, or entry to convert.
+    //  * @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).
     //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
     //  */
-    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
+    // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined {
     //
     //   if (keyOrNodeOrEntryOrRawElement === null || keyOrNodeOrEntryOrRawElement === undefined) return;
     //   if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
@@ -162,8 +162,8 @@ class RedBlackTree extends bst_1.BST {
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` 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.

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, BTNKeyOrNodeOrEntry, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
 import { BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
@@ -46,7 +46,7 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * 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<KeyOrNodeOrEntry<K, V, NODE>>, options?: TreeMultiMapOptions<K, V, R>);
+    constructor(keysOrNodesOrEntriesOrRawElements?: 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.
@@ -92,8 +92,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 | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` 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.
@@ -101,15 +101,15 @@ 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 | KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): NODE | undefined;
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): NODE | undefined;
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @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
      * an instance of the `TreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
+    isNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -120,7 +120,7 @@ export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      *
      * 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 | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
      * `keyOrNodeOrEntryOrRawElement` 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.
@@ -130,7 +130,7 @@ 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 | KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
+    add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -108,8 +108,8 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
     /**
      * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` 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.
@@ -140,8 +140,8 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
     }
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @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
      * an instance of the `TreeMultiMapNode` class.
      */
@@ -158,7 +158,7 @@ class TreeMultiMap extends rb_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 {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
      * `keyOrNodeOrEntryOrRawElement` 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.

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

@@ -220,7 +220,8 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
         if (vertex) {
             const neighbors = this.getNeighbors(vertex);
             for (const neighbor of neighbors) {
-                this._inEdgeMap.delete(neighbor);
+                // this._inEdgeMap.delete(neighbor);
+                this.deleteEdgeSrcToDest(vertex, neighbor);
             }
             this._outEdgeMap.delete(vertex);
             this._inEdgeMap.delete(vertex);

package/dist/data-structures/queue/deque.d.ts

@@ -34,6 +34,13 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * @return The size of the bucket
      */
     get bucketSize(): number;
+    protected _maxLen: number;
+    /**
+     * The maxLen function returns the max length of the deque.
+     *
+     * @return The max length of the deque
+     */
+    get maxLen(): number;
     protected _bucketFirst: number;
     /**
      * The function returns the value of the protected variable `_bucketFirst`.

package/dist/data-structures/queue/deque.js

@@ -25,6 +25,7 @@ class Deque extends base_1.IterableElementBase {
     constructor(elements = [], options) {
         super(options);
         this._bucketSize = 1 << 12;
+        this._maxLen = -1;
         this._bucketFirst = 0;
         this._firstInBucket = 0;
         this._bucketLast = 0;
@@ -33,9 +34,11 @@ class Deque extends base_1.IterableElementBase {
         this._buckets = [];
         this._size = 0;
         if (options) {
-            const { bucketSize } = options;
+            const { bucketSize, maxLen } = options;
             if (typeof bucketSize === 'number')
                 this._bucketSize = bucketSize;
+            if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0)
+                this._maxLen = maxLen;
         }
         let _size;
         if ('length' in elements) {
@@ -74,6 +77,14 @@ class Deque extends base_1.IterableElementBase {
     get bucketSize() {
         return this._bucketSize;
     }
+    /**
+     * The maxLen function returns the max length of the deque.
+     *
+     * @return The max length of the deque
+     */
+    get maxLen() {
+        return this._maxLen;
+    }
     /**
      * The function returns the value of the protected variable `_bucketFirst`.
      * @returns The value of the `_bucketFirst` property.
@@ -175,6 +186,8 @@ class Deque extends base_1.IterableElementBase {
         }
         this._size += 1;
         this._buckets[this._bucketLast][this._lastInBucket] = element;
+        if (this._maxLen > 0 && this._size > this._maxLen)
+            this.shift();
         return true;
     }
     /**
@@ -241,6 +254,8 @@ class Deque extends base_1.IterableElementBase {
         }
         this._size += 1;
         this._buckets[this._bucketFirst][this._firstInBucket] = element;
+        if (this._maxLen > 0 && this._size > this._maxLen)
+            this.pop();
         return true;
     }
     /**

package/dist/data-structures/queue/queue.d.ts

@@ -60,6 +60,18 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * array is empty, it returns `undefined`.
      */
     get last(): E | undefined;
+    _autoCompactRatio: number;
+    /**
+     * This function returns the value of the autoCompactRatio property.
+     * @returns The `autoCompactRatio` property of the object, which is a number.
+     */
+    get autoCompactRatio(): number;
+    /**
+     * The above function sets the autoCompactRatio property to a specified number in TypeScript.
+     * @param {number} v - The parameter `v` represents the value that will be assigned to the
+     * `_autoCompactRatio` property.
+     */
+    set autoCompactRatio(v: number);
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -70,7 +82,6 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      *
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
-     * @static
      * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
      * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
      * array.
@@ -160,6 +171,12 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * The clear function resets the elements array and offset to their initial values.
      */
     clear(): void;
+    /**
+     * The `compact` function in TypeScript slices the elements array based on the offset and resets the
+     * offset to zero.
+     * @returns The `compact()` method is returning a boolean value of `true`.
+     */
+    compact(): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/queue/queue.js

@@ -17,6 +17,11 @@ class Queue extends base_1.IterableElementBase {
         super(options);
         this._elements = [];
         this._offset = 0;
+        this._autoCompactRatio = 0.5;
+        if (options) {
+            const { autoCompactRatio = 0.5 } = options;
+            this._autoCompactRatio = autoCompactRatio;
+        }
         if (elements) {
             for (const el of elements) {
                 if (this.toElementFn)
@@ -77,6 +82,21 @@ class Queue extends base_1.IterableElementBase {
     get last() {
         return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
     }
+    /**
+     * This function returns the value of the autoCompactRatio property.
+     * @returns The `autoCompactRatio` property of the object, which is a number.
+     */
+    get autoCompactRatio() {
+        return this._autoCompactRatio;
+    }
+    /**
+     * The above function sets the autoCompactRatio property to a specified number in TypeScript.
+     * @param {number} v - The parameter `v` represents the value that will be assigned to the
+     * `_autoCompactRatio` property.
+     */
+    set autoCompactRatio(v) {
+        this._autoCompactRatio = v;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -87,7 +107,6 @@ class Queue extends base_1.IterableElementBase {
      *
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
-     * @static
      * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
      * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
      * array.
@@ -128,12 +147,8 @@ class Queue extends base_1.IterableElementBase {
             return undefined;
         const first = this.first;
         this._offset += 1;
-        if (this.offset * 2 < this.elements.length)
-            return first;
-        // only delete dequeued elements when reaching half size
-        // to decrease latency of shifting elements.
-        this._elements = this.elements.slice(this.offset);
-        this._offset = 0;
+        if (this.offset / this.elements.length > this.autoCompactRatio)
+            this.compact();
         return first;
     }
     /**
@@ -209,6 +224,16 @@ class Queue extends base_1.IterableElementBase {
         this._elements = [];
         this._offset = 0;
     }
+    /**
+     * The `compact` function in TypeScript slices the elements array based on the offset and resets the
+     * offset to zero.
+     * @returns The `compact()` method is returning a boolean value of `true`.
+     */
+    compact() {
+        this._elements = this.elements.slice(this.offset);
+        this._offset = 0;
+        return true;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/interfaces/binary-tree.d.ts

@@ -1,9 +1,9 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, KeyOrNodeOrEntry } from '../types';
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKeyOrNodeOrEntry } from '../types';
 export interface IBinaryTree<K = any, V = any, R = [K, V], NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTreeNested<K, V, R, NODE>> {
     createNode(key: K, value?: NODE['value']): NODE;
     createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
-    add(keyOrNodeOrEntryOrRawElement: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
-    addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
+    add(keyOrNodeOrEntryOrRawElement: BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
+    addMany(nodes: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
     delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<NODE>[];
 }

package/dist/types/common.d.ts

@@ -1,36 +1,15 @@
 export type CP = 1 | -1 | 0;
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
 export type IterationType = 'ITERATIVE' | 'RECURSIVE';
 export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
 export type Comparator<K> = (a: K, b: K) => number;
 export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 export type NodeDisplayLayout = [string[], number, number, number];
-export type BTNCallback<N, D = any> = (node: N) => D;
 export interface IterableWithSize<T> extends Iterable<T> {
     size: number | ((...args: any[]) => number);
 }
 export interface IterableWithLength<T> extends Iterable<T> {
     length: number | ((...args: any[]) => number);
 }
+export type OptValue<V> = V | undefined;
 export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
-export type BinaryTreePrintOptions = {
-    isShowUndefined?: boolean;
-    isShowNull?: boolean;
-    isShowRedBlackNIL?: boolean;
-};
-export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
-export type BTNKeyOrNode<K, N> = K | null | undefined | N;
-export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
-export type BTNodePureKeyOrNode<K, N> = K | N;
-export type BTNPureKeyOrNodeOrEntry<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
-export type BSTNKeyOrNode<K, N> = K | undefined | N;
-export type BinaryTreeDeleteResult<N> = {
-    deleted: N | null | undefined;
-    needBalanced: N | null | undefined;
-};
 export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

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

@@ -1,8 +1,25 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
-import { BTNEntry, IterationType } from '../../common';
+import { IterationType, OptValue } from '../../common';
 export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeNested<K, V, R, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions<K, V, R> = {
     iterationType?: IterationType;
     toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
 };
+export type BinaryTreePrintOptions = {
+    isShowUndefined?: boolean;
+    isShowNull?: boolean;
+    isShowRedBlackNIL?: boolean;
+};
+export type OptBTNOrNull<NODE> = NODE | null | undefined;
+export type OptBTNKeyOrNull<K> = K | null | undefined;
+export type BTNEntry<K, V> = [OptBTNKeyOrNull<K>, OptValue<V>];
+export type BTNKeyOrNode<K, NODE> = OptBTNKeyOrNull<K> | NODE;
+export type BTNKeyOrNodeOrEntry<K, V, NODE> = BTNEntry<K, V> | BTNKeyOrNode<K, NODE>;
+export type BTNPureKeyOrNode<K, NODE> = K | NODE;
+export type BTNPureKeyOrNodeOrEntry<K, V, NODE> = [K, OptValue<V>] | BTNPureKeyOrNode<K, NODE>;
+export type BinaryTreeDeleteResult<NODE> = {
+    deleted: OptBTNOrNull<NODE>;
+    needBalanced: OptBTNOrNull<NODE>;
+};
+export type BTNCallback<NODE, D = any> = (node: NODE) => D;

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

@@ -6,3 +6,6 @@ export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R,
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
     comparator?: Comparator<K>;
 };
+export type OptBSTNKey<K> = K | undefined;
+export type OptBSTN<NODE> = NODE | undefined;
+export type BSTNKeyOrNode<K, NODE> = OptBSTNKey<K> | NODE;

package/dist/types/data-structures/queue/deque.d.ts

@@ -1,4 +1,5 @@
 import { IterableElementBaseOptions } from '../base';
 export type DequeOptions<E, R> = {
     bucketSize?: number;
+    maxLen?: number;
 } & IterableElementBaseOptions<E, R>;

package/dist/types/data-structures/queue/queue.d.ts

@@ -1,2 +1,4 @@
 import { IterableElementBaseOptions } from '../base';
-export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {
+    autoCompactRatio?: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deque-typed",
-  "version": "1.52.0",
+  "version": "1.52.2",
   "description": "Deque. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -119,6 +119,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.52.0"
+    "data-structure-typed": "^1.52.2"
   }
 }