data-structure-typed 1.18.7 → 1.18.8

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

@@ -184,41 +184,6 @@ var DirectedGraph = /** @class */ (function (_super) {
         }
         return edges[0] || null;
     };
-    /**
-     * The `addEdge` function adds a directed edge to a graph if the source and destination vertices exist.
-     * @param edge - The parameter `edge` is of type `E`, which represents a directed edge in a graph. It
-     * contains two properties:
-     * @returns The method `addEdge` returns a boolean value. It returns `true` if the edge was successfully added to the
-     * graph, and `false` if either the source or destination vertex of the edge is not present in the graph.
-     */
-    DirectedGraph.prototype.addEdge = function (edge) {
-        if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
-            return false;
-        }
-        var srcVertex = this._getVertex(edge.src);
-        var destVertex = this._getVertex(edge.dest);
-        // TODO after no-non-null-assertion not ensure the logic
-        if (srcVertex && destVertex) {
-            var srcOutEdges = this._outEdgeMap.get(srcVertex);
-            if (srcOutEdges) {
-                srcOutEdges.push(edge);
-            }
-            else {
-                this._outEdgeMap.set(srcVertex, [edge]);
-            }
-            var destInEdges = this._inEdgeMap.get(destVertex);
-            if (destInEdges) {
-                destInEdges.push(edge);
-            }
-            else {
-                this._inEdgeMap.set(destVertex, [edge]);
-            }
-            return true;
-        }
-        else {
-            return false;
-        }
-    };
     /**
      * The `removeEdgeBetween` function removes an edge between two vertices in a directed graph and returns the removed
      * edge, or null if the edge was not found.
@@ -400,14 +365,17 @@ var DirectedGraph = /** @class */ (function (_super) {
         return destinations;
     };
     /**
-     * The `topologicalSort` function performs a topological sort on a directed graph and returns the sorted vertices in
-     * reverse order, or null if the graph contains a cycle.
-     * @returns The function `topologicalSort()` returns an array of `V` or `VertexId` objects in
-     * topological order, or `null` if there is a cycle in the graph.
+     * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
+     * in the sorted order, or null if the graph contains a cycle.
+     * @param {'vertex' | 'id'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
+     * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'id'. If 'vertex' is
+     * specified, the vertices themselves will be used for sorting. If 'id' is specified, the ids of
+     * @returns an array of vertices or vertex IDs in topological order, or null if there is a cycle in the graph.
      */
-    DirectedGraph.prototype.topologicalSort = function () {
+    DirectedGraph.prototype.topologicalSort = function (propertyName) {
         var e_2, _a, e_3, _b;
         var _this = this;
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
         // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
         var statusMap = new Map();
@@ -469,6 +437,8 @@ var DirectedGraph = /** @class */ (function (_super) {
         }
         if (hasCycle)
             return null;
+        if (propertyName === 'id')
+            sorted = sorted.map(function (vertex) { return vertex instanceof DirectedVertex ? vertex.id : vertex; });
         return sorted.reverse();
     };
     /**
@@ -482,7 +452,6 @@ var DirectedGraph = /** @class */ (function (_super) {
         });
         return edges;
     };
-    /**--- start find cycles --- */
     /**
      * The function `getNeighbors` returns an array of neighboring vertices of a given vertex in a directed graph.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a `V`
@@ -515,7 +484,7 @@ var DirectedGraph = /** @class */ (function (_super) {
         }
         return neighbors;
     };
-    /**--- end find cycles --- */
+    /**--- start find cycles --- */
     /**
      * The function "getEndsOfEdge" returns the source and destination vertices of a directed edge if it exists in the
      * graph, otherwise it returns null.
@@ -536,6 +505,42 @@ var DirectedGraph = /** @class */ (function (_super) {
             return null;
         }
     };
+    /**--- end find cycles --- */
+    /**
+     * The `_addEdgeOnly` function adds a directed edge to a graph if the source and destination vertices exist.
+     * @param edge - The parameter `edge` is of type `E`, which represents a directed edge in a graph. It
+     * contains two properties:
+     * @returns The method `_addEdgeOnly` returns a boolean value. It returns `true` if the edge was successfully added to the
+     * graph, and `false` if either the source or destination vertex of the edge is not present in the graph.
+     */
+    DirectedGraph.prototype._addEdgeOnly = function (edge) {
+        if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
+            return false;
+        }
+        var srcVertex = this._getVertex(edge.src);
+        var destVertex = this._getVertex(edge.dest);
+        // TODO after no-non-null-assertion not ensure the logic
+        if (srcVertex && destVertex) {
+            var srcOutEdges = this._outEdgeMap.get(srcVertex);
+            if (srcOutEdges) {
+                srcOutEdges.push(edge);
+            }
+            else {
+                this._outEdgeMap.set(srcVertex, [edge]);
+            }
+            var destInEdges = this._inEdgeMap.get(destVertex);
+            if (destInEdges) {
+                destInEdges.push(edge);
+            }
+            else {
+                this._inEdgeMap.set(destVertex, [edge]);
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
     DirectedGraph.prototype._setOutEdgeMap = function (value) {
         this._outEdgeMap = value;
     };

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

@@ -61,13 +61,6 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * @returns an instance of `E` or `null`.
      */
     getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null;
-    /**
-     * The function adds an undirected edge to a graph by updating the adjacency list.
-     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
-     * array of two vertices connected by the edge.
-     * @returns a boolean value.
-     */
-    addEdge(edge: E): boolean;
     /**
      * The function removes an edge between two vertices in an undirected graph.
      * @param {V | VertexId} v1 - The parameter `v1` represents either an `V` object or
@@ -122,5 +115,12 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * exists in the graph. If the edge does not exist, it returns `null`.
      */
     getEndsOfEdge(edge: E): [V, V] | null;
+    /**
+     * The function adds an undirected edge to a graph by updating the adjacency list.
+     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
+     * array of two vertices connected by the edge.
+     * @returns a boolean value.
+     */
+    protected _addEdgeOnly(edge: E): boolean;
     protected _setEdges(v: Map<V, E[]>): void;
 }

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

@@ -14,17 +14,6 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -50,6 +39,17 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UndirectedGraph = exports.UndirectedEdge = exports.UndirectedVertex = void 0;
 /**
@@ -165,40 +165,6 @@ var UndirectedGraph = /** @class */ (function (_super) {
         }
         return edges ? edges[0] || null : null;
     };
-    /**
-     * The function adds an undirected edge to a graph by updating the adjacency list.
-     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
-     * array of two vertices connected by the edge.
-     * @returns a boolean value.
-     */
-    UndirectedGraph.prototype.addEdge = function (edge) {
-        var e_1, _a;
-        try {
-            for (var _b = __values(edge.vertices), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var end = _c.value;
-                var endVertex = this._getVertex(end);
-                if (endVertex === null)
-                    return false;
-                if (endVertex) {
-                    var edges = this._edges.get(endVertex);
-                    if (edges) {
-                        edges.push(edge);
-                    }
-                    else {
-                        this._edges.set(endVertex, [edge]);
-                    }
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return true;
-    };
     /**
      * The function removes an edge between two vertices in an undirected graph.
      * @param {V | VertexId} v1 - The parameter `v1` represents either an `V` object or
@@ -287,7 +253,7 @@ var UndirectedGraph = /** @class */ (function (_super) {
      * @returns an array of UndirectedVertex objects.
      */
     UndirectedGraph.prototype.getNeighbors = function (vertexOrId) {
-        var e_2, _a;
+        var e_1, _a;
         var neighbors = [];
         var vertex = this._getVertex(vertexOrId);
         if (vertex) {
@@ -301,12 +267,12 @@ var UndirectedGraph = /** @class */ (function (_super) {
                     }
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
                     if (neighborEdges_1_1 && !neighborEdges_1_1.done && (_a = neighborEdges_1.return)) _a.call(neighborEdges_1);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_1) throw e_1.error; }
             }
         }
         return neighbors;
@@ -332,6 +298,40 @@ var UndirectedGraph = /** @class */ (function (_super) {
             return null;
         }
     };
+    /**
+     * The function adds an undirected edge to a graph by updating the adjacency list.
+     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
+     * array of two vertices connected by the edge.
+     * @returns a boolean value.
+     */
+    UndirectedGraph.prototype._addEdgeOnly = function (edge) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(edge.vertices), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var end = _c.value;
+                var endVertex = this._getVertex(end);
+                if (endVertex === null)
+                    return false;
+                if (endVertex) {
+                    var edges = this._edges.get(endVertex);
+                    if (edges) {
+                        edges.push(edge);
+                    }
+                    else {
+                        this._edges.set(endVertex, [edge]);
+                    }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return true;
+    };
     UndirectedGraph.prototype._setEdges = function (v) {
         this._edges = v;
     };

package/dist/data-structures/interfaces/abstract-binary-tree.d.ts

@@ -13,7 +13,6 @@ export interface IAbstractBinaryTreeNode<T, FAMILY extends IAbstractBinaryTreeNo
     get parent(): FAMILY | null | undefined;
     set parent(v: FAMILY | null | undefined);
     get familyPosition(): FamilyPosition;
-    set familyPosition(v: FamilyPosition);
     get count(): number;
     set count(v: number);
     get height(): number;
@@ -22,7 +21,7 @@ export interface IAbstractBinaryTreeNode<T, FAMILY extends IAbstractBinaryTreeNo
     clone(): FAMILY | null;
 }
 export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N>> {
-    createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null;
     get loopType(): LoopType;
     get visitedId(): BinaryTreeNodeId[];
     get visitedVal(): Array<N['val']>;
@@ -31,7 +30,7 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     get visitedLeftSum(): number[];
     get autoIncrementId(): boolean;
     get maxId(): number;
-    get isDuplicatedVal(): boolean;
+    get isMergeDuplicatedVal(): boolean;
     get root(): N | null;
     get size(): number;
     get count(): number;

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

@@ -1,8 +1,7 @@
 import { VertexId } from '../types';
 export interface IAbstractGraph<V, E> {
     hasVertex(vertexOrId: V | VertexId): boolean;
-    createAddVertex(id: VertexId, val?: V): boolean;
-    addVertex(newVertex: V): boolean;
+    addVertex(id: VertexId, val?: V): boolean;
     removeVertex(vertexOrId: V | VertexId): boolean;
     removeAllVertices(vertices: V[] | VertexId[]): boolean;
     degreeOf(vertexOrId: V | VertexId): number;
@@ -10,8 +9,7 @@ export interface IAbstractGraph<V, E> {
     hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
     getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
     edgeSet(): E[];
-    createAddEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
-    addEdge(edge: E): boolean;
+    addEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
     removeEdge(edge: E): E | null;
     setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
     getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;

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

@@ -4,7 +4,7 @@ import { BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
 export interface IAVLTreeNode<T, FAMILY extends IAVLTreeNode<T, FAMILY>> extends IBSTNode<T, FAMILY> {
 }
 export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
-    add(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null;
     remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
     balanceFactor(node: N): number;
     updateHeight(node: N): void;

package/dist/data-structures/interfaces/bst.d.ts

@@ -5,8 +5,8 @@ export interface IBSTNode<T, FAMILY extends IBSTNode<T, FAMILY>> extends IBinary
     createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
 export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
-    createNode(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N;
-    add(id: BinaryTreeNodeId, val: N['val'] | null, count: number): N | null;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null;
     get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
     lastKey(): BinaryTreeNodeId;
     remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];

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

@@ -2,8 +2,8 @@ import { RBTreeNode } from '../binary-tree';
 import { IBST, IBSTNode } from './bst';
 import { BinaryTreeNodeId } from '../types';
 export interface IRBTreeNode<T, FAMILY extends IRBTreeNode<T, FAMILY>> extends IBSTNode<T, FAMILY> {
-    createNode(id: BinaryTreeNodeId, val?: T | null, count?: number): FAMILY;
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
 export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
-    createNode(id: BinaryTreeNodeId, val?: N | null, count?: number): N;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
 }

package/dist/data-structures/interfaces/tree-multiset.d.ts

@@ -1 +1,7 @@
-export {};
+import { TreeMultiSetNode } from '../binary-tree';
+import { IBSTNode } from './bst';
+import { IAVLTree } from './avl-tree';
+export interface ITreeMultiSetNode<T, FAMILY extends ITreeMultiSetNode<T, FAMILY>> extends IBSTNode<T, FAMILY> {
+}
+export interface ITreeMultiSet<N extends TreeMultiSetNode<N['val'], N>> extends IAVLTree<N> {
+}

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

@@ -1,11 +1,8 @@
 export declare class TreeNode<T = number> {
-    constructor(id: string, name?: string, value?: T, children?: TreeNode<T>[]);
+    constructor(id: string, value?: T, children?: TreeNode<T>[]);
     private _id;
     get id(): string;
     set id(value: string);
-    private _name?;
-    get name(): string | undefined;
-    set name(value: string | undefined);
     private _value?;
     get value(): T | undefined;
     set value(value: T | undefined);

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

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeNode = void 0;
 var TreeNode = /** @class */ (function () {
-    function TreeNode(id, name, value, children) {
+    function TreeNode(id, value, children) {
         this._id = id;
-        this._name = name || '';
         this._value = value || undefined;
         this._children = children || [];
     }
@@ -18,16 +17,6 @@ var TreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TreeNode.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        set: function (value) {
-            this._name = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
     Object.defineProperty(TreeNode.prototype, "value", {
         get: function () {
             return this._value;

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

@@ -10,9 +10,13 @@ export declare enum LoopType {
     RECURSIVE = "RECURSIVE"
 }
 export declare enum FamilyPosition {
-    ROOT = 0,
-    LEFT = 1,
-    RIGHT = 2
+    ROOT = "ROOT",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    ROOT_LEFT = "ROOT_LEFT",
+    ROOT_RIGHT = "ROOT_RIGHT",
+    ISOLATED = "ISOLATED",
+    MAL_NODE = "MAL_NODE"
 }
 export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
 export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
@@ -24,9 +28,9 @@ export type BinaryTreeDeletedResult<N> = {
 };
 export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
 export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractBinaryTreeNodeProperty<N>[];
-export type AbstractRecursiveBinaryTreeNode<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AbstractBinaryTreeNodeNested<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type AbstractBinaryTreeOptions = {
     loopType?: LoopType;
     autoIncrementId?: boolean;
-    isDuplicatedVal?: boolean;
+    isMergeDuplicatedVal?: boolean;
 };

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

@@ -11,11 +11,15 @@ var LoopType;
 (function (LoopType) {
     LoopType["ITERATIVE"] = "ITERATIVE";
     LoopType["RECURSIVE"] = "RECURSIVE";
-})(LoopType || (exports.LoopType = LoopType = {}));
+})(LoopType = exports.LoopType || (exports.LoopType = {}));
 /* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
 var FamilyPosition;
 (function (FamilyPosition) {
-    FamilyPosition[FamilyPosition["ROOT"] = 0] = "ROOT";
-    FamilyPosition[FamilyPosition["LEFT"] = 1] = "LEFT";
-    FamilyPosition[FamilyPosition["RIGHT"] = 2] = "RIGHT";
-})(FamilyPosition || (exports.FamilyPosition = FamilyPosition = {}));
+    FamilyPosition["ROOT"] = "ROOT";
+    FamilyPosition["LEFT"] = "LEFT";
+    FamilyPosition["RIGHT"] = "RIGHT";
+    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
+    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
+    FamilyPosition["ISOLATED"] = "ISOLATED";
+    FamilyPosition["MAL_NODE"] = "MAL_NODE";
+})(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));

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

@@ -1,4 +1,4 @@
 import { AVLTreeNode } from '../binary-tree';
 import { BSTOptions } from './bst';
-export type RecursiveAVLTreeNode<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeNodeNested<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type AVLTreeOptions = BSTOptions & {};

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

@@ -1,4 +1,4 @@
 import { BinaryTreeNode } from '../binary-tree';
 import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
-export type RecursiveBinaryTreeNode<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions = AbstractBinaryTreeOptions & {};

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

@@ -2,7 +2,7 @@ import { BSTNode } from '../binary-tree';
 import type { BinaryTreeOptions } from './binary-tree';
 import { BinaryTreeNodeId } from './abstract-binary-tree';
 export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-export type RecursiveBSTNode<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions = BinaryTreeOptions & {
     comparator?: BSTComparator;
 };

package/dist/data-structures/types/bst.js

@@ -6,4 +6,4 @@ var CP;
     CP["lt"] = "lt";
     CP["eq"] = "eq";
     CP["gt"] = "gt";
-})(CP || (exports.CP = CP = {}));
+})(CP = exports.CP || (exports.CP = {}));

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

@@ -6,4 +6,4 @@ var TopologicalProperty;
     TopologicalProperty["VAL"] = "VAL";
     TopologicalProperty["NODE"] = "NODE";
     TopologicalProperty["ID"] = "ID";
-})(TopologicalProperty || (exports.TopologicalProperty = TopologicalProperty = {}));
+})(TopologicalProperty = exports.TopologicalProperty || (exports.TopologicalProperty = {}));

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

@@ -1,8 +1 @@
-export type IdObject = {
-    id: number;
-} & {
-    [key: string]: any;
-};
-export type KeyValObject = {
-    [key: string]: any;
-};
+export {};

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

@@ -1,6 +1,8 @@
 import { BinaryTreeOptions } from './binary-tree';
+import { RBTreeNode } from '../binary-tree';
 export declare enum RBColor {
     RED = "RED",
     BLACK = "BLACK"
 }
+export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RBTreeOptions = BinaryTreeOptions & {};

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

@@ -5,4 +5,4 @@ var RBColor;
 (function (RBColor) {
     RBColor["RED"] = "RED";
     RBColor["BLACK"] = "BLACK";
-})(RBColor || (exports.RBColor = RBColor = {}));
+})(RBColor = exports.RBColor || (exports.RBColor = {}));

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

@@ -1,6 +1,6 @@
-import { BSTOptions } from './bst';
 import { TreeMultiSetNode } from '../binary-tree';
-export type RecursiveTreeMultiSetNode<T> = TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultiSetOptions = Omit<BSTOptions, 'isDuplicatedVal'> & {
-    isDuplicatedVal: true;
+import { AVLTreeOptions } from './avl-tree';
+export type TreeMultiSetNodeNested<T> = TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type TreeMultiSetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedVal'> & {
+    isMergeDuplicatedVal: true;
 };

package/dist/utils/types/utils.d.ts

@@ -5,3 +5,21 @@ export type Thunk = () => ReturnType<ToThunkFn> & {
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type KeyValueObject = {
+    [key: string]: any;
+};
+export type KeyValueObjectWithId = {
+    [key: string]: any;
+    id: string | number | symbol;
+};
+export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
+export type ObjectWithoutId = Omit<KeyValueObject, 'id'>;
+export type ObjectWithNonNumberId = {
+    [key: string]: any;
+    id: string | boolean | symbol | null | object | undefined;
+};
+export type ObjectWithNumberId = {
+    [key: string]: any;
+    id: number;
+};
+export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | Function | never;

package/dist/utils/utils.d.ts

@@ -7,7 +7,7 @@ export declare const arrayRemove: <T>(array: T[], predicate: (item: T, index: nu
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from './types';
+import type { NonNumberNonObjectButDefined, ObjectWithNonNumberId, ObjectWithNumberId, ObjectWithoutId, Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from './types';
 export declare const THUNK_SYMBOL: unique symbol;
 export declare const isThunk: (fnOrValue: any) => boolean;
 export declare const toThunk: (fn: ToThunkFn) => Thunk;
@@ -17,3 +17,8 @@ export declare const trampoline: (fn: TrlFn) => ((...args: [...Parameters<TrlFn>
 export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Parameters<TrlAsyncFn>]) => Promise<any>) & {
     cont: (...args: [...Parameters<TrlAsyncFn>]) => Thunk;
 };
+export declare function isNonNumberNonObjectButDefined(val: any): val is NonNumberNonObjectButDefined;
+export declare function isObjectWithoutId(val: any): val is ObjectWithoutId;
+export declare function isObjectWithNonNumberId(val: any): val is ObjectWithNonNumberId;
+export declare function isObjectWithNumberId(val: any): val is ObjectWithNumberId;
+export declare function isNumber(val: any): val is number;