data-structure-typed 1.17.3 → 1.18.0

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

@@ -38,7 +38,7 @@ var CP;
     CP[CP["lt"] = -1] = "lt";
     CP[CP["eq"] = 0] = "eq";
     CP[CP["gt"] = 1] = "gt";
-})(CP = exports.CP || (exports.CP = {}));
+})(CP || (exports.CP = CP = {}));
 var BSTNode = /** @class */ (function (_super) {
     __extends(BSTNode, _super);
     function BSTNode() {
@@ -83,14 +83,13 @@ var BST = /** @class */ (function (_super) {
      * @returns The method `add` returns a `BSTNode<T>` object or `null`.
      */
     BST.prototype.add = function (id, val, count) {
-        var _a;
         if (count === void 0) { count = 1; }
         var inserted = null;
         var newNode = this.createNode(id, val, count);
         if (this.root === null) {
-            this.root = newNode;
-            this.size++;
-            this.count += (_a = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _a !== void 0 ? _a : 1;
+            this._setRoot(newNode);
+            this._setSize(this.size + 1);
+            this._setCount(this.count + count);
             inserted = (this.root);
         }
         else {
@@ -101,7 +100,7 @@ var BST = /** @class */ (function (_super) {
                     if (this._compare(cur.id, id) === CP.eq) {
                         if (newNode) {
                             cur.count += newNode.count;
-                            this.count += newNode.count;
+                            this._setCount(this.count + newNode.count);
                             cur.val = newNode.val;
                         }
                         //Duplicates are not accepted.
@@ -117,8 +116,8 @@ var BST = /** @class */ (function (_super) {
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
-                            this.size++;
-                            this.count += newNode.count;
+                            this._setSize(this.size + 1);
+                            this._setCount(this.count + newNode.count);
                             traversing = false;
                             inserted = cur.left;
                         }
@@ -137,8 +136,8 @@ var BST = /** @class */ (function (_super) {
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
-                            this.size++;
-                            this.count += newNode.count;
+                            this._setSize(this.size + 1);
+                            this._setCount(this.count + newNode.count);
                             traversing = false;
                             inserted = (cur.right);
                         }
@@ -208,13 +207,13 @@ var BST = /** @class */ (function (_super) {
         var needBalanced = null, orgCurrent = curr;
         if (curr.count > 1 && !ignoreCount) {
             curr.count--;
-            this.count--;
+            this._setCount(this.count - 1);
         }
         else {
             if (!curr.left) {
                 if (!parent) {
                     if (curr.right !== undefined)
-                        this.root = curr.right;
+                        this._setRoot(curr.right);
                 }
                 else {
                     switch (curr.familyPosition) {
@@ -242,8 +241,8 @@ var BST = /** @class */ (function (_super) {
                     }
                 }
             }
-            this.size--;
-            this.count -= curr.count;
+            this._setSize(this.size - 1);
+            this._setCount(this.count - curr.count);
         }
         bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
         return bstDeletedResult;
@@ -267,7 +266,7 @@ var BST = /** @class */ (function (_super) {
         if (!this.root)
             return [];
         var result = [];
-        if (this._loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === binary_tree_1.LoopType.recursive) {
             var _traverse_1 = function (cur) {
                 if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
@@ -340,7 +339,7 @@ var BST = /** @class */ (function (_super) {
             return needSum;
         };
         var sum = 0;
-        if (this._loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === binary_tree_1.LoopType.recursive) {
             var _traverse_2 = function (cur) {
                 var compared = _this._compare(cur.id, id);
                 if (compared === CP.eq) {
@@ -427,7 +426,7 @@ var BST = /** @class */ (function (_super) {
                     break;
             }
         };
-        if (this._loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === binary_tree_1.LoopType.recursive) {
             var _traverse_3 = function (cur) {
                 var compared = _this._compare(cur.id, node.id);
                 _sumByPropertyName(cur);
@@ -468,7 +467,7 @@ var BST = /** @class */ (function (_super) {
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (this._loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === binary_tree_1.LoopType.recursive) {
             var buildBalanceBST_1 = function (l, r) {
                 if (l > r)
                     return;
@@ -509,7 +508,7 @@ var BST = /** @class */ (function (_super) {
         if (!this.root)
             return true;
         var balanced = true;
-        if (this._loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === binary_tree_1.LoopType.recursive) {
             var _height_1 = function (cur) {
                 if (!cur)
                     return 0;

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

@@ -8,53 +8,26 @@
 import type { SegmentTreeNodeVal } from '../types';
 export declare class SegmentTreeNode {
     constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
-    protected _start: number;
+    private _start;
     get start(): number;
     set start(v: number);
-    protected _end: number;
+    private _end;
     get end(): number;
     set end(v: number);
-    protected _val: SegmentTreeNodeVal | null;
+    private _val;
     get val(): SegmentTreeNodeVal | null;
     set val(v: SegmentTreeNodeVal | null);
-    protected _sum: number;
+    private _sum;
     get sum(): number;
     set sum(v: number);
-    protected _left: SegmentTreeNode | null;
+    private _left;
     get left(): SegmentTreeNode | null;
     set left(v: SegmentTreeNode | null);
-    protected _right: SegmentTreeNode | null;
+    private _right;
     get right(): SegmentTreeNode | null;
     set right(v: SegmentTreeNode | null);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getStart(): number;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getEnd(): number;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getVal(): SegmentTreeNodeVal | null;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getSum(): number;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getLeft(): SegmentTreeNode | null;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getRight(): SegmentTreeNode | null;
 }
 export declare class SegmentTree {
-    protected _values: number[];
-    protected _start: number;
-    protected _end: number;
     /**
      * The constructor initializes the values, start, end, and root properties of an object.
      * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
@@ -65,13 +38,14 @@ export declare class SegmentTree {
      * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
      */
     constructor(values: number[], start?: number, end?: number);
-    protected _root: SegmentTreeNode | null;
+    private _values;
+    get values(): number[];
+    private _start;
+    get start(): number;
+    private _end;
+    get end(): number;
+    private _root;
     get root(): SegmentTreeNode | null;
-    set root(v: SegmentTreeNode | null);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getRoot(): SegmentTreeNode | null;
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
      * for each segment.
@@ -102,4 +76,8 @@ export declare class SegmentTree {
      * @returns The function `querySumByRange` returns a number.
      */
     querySumByRange(indexA: number, indexB: number): number;
+    protected _setValues(value: number[]): void;
+    protected _setStart(value: number): void;
+    protected _setEnd(value: number): void;
+    protected _setRoot(v: SegmentTreeNode | null): void;
 }

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

@@ -81,42 +81,6 @@ var SegmentTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getStart = function () {
-        return this._start;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getEnd = function () {
-        return this._end;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getVal = function () {
-        return this._val;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getSum = function () {
-        return this._sum;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getLeft = function () {
-        return this._left;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getRight = function () {
-        return this._right;
-    };
     return SegmentTreeNode;
 }());
 exports.SegmentTreeNode = SegmentTreeNode;
@@ -140,22 +104,34 @@ var SegmentTree = /** @class */ (function () {
         this._end = end;
         this._root = this.build(start, end);
     }
+    Object.defineProperty(SegmentTree.prototype, "values", {
+        get: function () {
+            return this._values;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTree.prototype, "start", {
+        get: function () {
+            return this._start;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTree.prototype, "end", {
+        get: function () {
+            return this._end;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(SegmentTree.prototype, "root", {
         get: function () {
             return this._root;
         },
-        set: function (v) {
-            this._root = v;
-        },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTree.prototype.getRoot = function () {
-        return this._root;
-    };
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
      * for each segment.
@@ -166,9 +142,8 @@ var SegmentTree = /** @class */ (function () {
      * @returns a SegmentTreeNode object.
      */
     SegmentTree.prototype.build = function (start, end) {
-        if (start === end) {
+        if (start === end)
             return new SegmentTreeNode(start, end, this._values[start]);
-        }
         var mid = start + Math.floor((end - start) / 2);
         var left = this.build(start, mid);
         var right = this.build(mid + 1, end);
@@ -264,6 +239,18 @@ var SegmentTree = /** @class */ (function () {
         };
         return dfs(root, indexA, indexB);
     };
+    SegmentTree.prototype._setValues = function (value) {
+        this._values = value;
+    };
+    SegmentTree.prototype._setStart = function (value) {
+        this._start = value;
+    };
+    SegmentTree.prototype._setEnd = function (value) {
+        this._end = value;
+    };
+    SegmentTree.prototype._setRoot = function (v) {
+        this._root = v;
+    };
     return SegmentTree;
 }());
 exports.SegmentTree = SegmentTree;

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

@@ -4,33 +4,20 @@ export declare class AbstractVertex {
     protected _id: VertexId;
     get id(): VertexId;
     set id(v: VertexId);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getId(): VertexId;
 }
 export declare abstract class AbstractEdge {
-    static DEFAULT_EDGE_WEIGHT: number;
     /**
      * The function is a protected constructor that initializes the weight and generates a unique hash code for an edge.
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
      * no weight is provided, it will default to the value of `AbstractEdge.DEFAULT_EDGE_WEIGHT`.
      */
     protected constructor(weight?: number);
-    private _weight;
+    protected _weight: number;
     get weight(): number;
     set weight(v: number);
-    private _hashCode;
+    protected _hashCode: string;
     get hashCode(): string;
-    set hashCode(v: string);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getWeight(): number;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getHashCode(): string;
+    protected _setHashCode(v: string): void;
 }
 export declare abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements IGraph<V, E> {
     protected _vertices: Map<VertexId, V>;

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

@@ -60,12 +60,6 @@ var AbstractVertex = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    AbstractVertex.prototype.getId = function () {
-        return this._id;
-    };
     return AbstractVertex;
 }());
 exports.AbstractVertex = AbstractVertex;
@@ -76,9 +70,7 @@ var AbstractEdge = /** @class */ (function () {
      * no weight is provided, it will default to the value of `AbstractEdge.DEFAULT_EDGE_WEIGHT`.
      */
     function AbstractEdge(weight) {
-        if (weight === undefined)
-            weight = AbstractEdge.DEFAULT_EDGE_WEIGHT;
-        this._weight = weight;
+        this._weight = weight !== undefined ? weight : 1;
         this._hashCode = (0, utils_1.uuidV4)();
     }
     Object.defineProperty(AbstractEdge.prototype, "weight", {
@@ -95,25 +87,12 @@ var AbstractEdge = /** @class */ (function () {
         get: function () {
             return this._hashCode;
         },
-        set: function (v) {
-            this._hashCode = v;
-        },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    AbstractEdge.prototype.getWeight = function () {
-        return this._weight;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    AbstractEdge.prototype.getHashCode = function () {
-        return this._hashCode;
+    AbstractEdge.prototype._setHashCode = function (v) {
+        this._hashCode = v;
     };
-    AbstractEdge.DEFAULT_EDGE_WEIGHT = 1;
     return AbstractEdge;
 }());
 exports.AbstractEdge = AbstractEdge;

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

@@ -25,14 +25,6 @@ export declare class DirectedEdge extends AbstractEdge {
     private _dest;
     get dest(): VertexId;
     set dest(v: VertexId);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getSrc(): VertexId;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getDest(): VertexId;
 }
 export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
     protected _outEdgeMap: Map<V, E[]>;
@@ -147,10 +139,10 @@ export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedE
      * when stored with adjacency matrix time: O(V^2)
      * The `topologicalSort` function performs a topological sort on a graph and returns the sorted vertices in reverse
      * order, or null if the graph contains a cycle.
-     * @returns The `topologicalSort()` function returns an array of vertices (`V[]`) in topological order if there is no
-     * cycle in the graph. If there is a cycle, it returns `null`.
+     * @returns The function `topologicalSort()` returns an array of vertices in topological order if there is no cycle in
+     * the graph. If there is a cycle, it returns `null`.
      */
-    topologicalSort(): V[] | null;
+    topologicalSort(): Array<V | VertexId> | null;
     /**--- end find cycles --- */
     /**
      * The `edgeSet` function returns an array of all the edges in the graph.

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

@@ -111,18 +111,6 @@ var DirectedEdge = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    DirectedEdge.prototype.getSrc = function () {
-        return this._src;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    DirectedEdge.prototype.getDest = function () {
-        return this._dest;
-    };
     return DirectedEdge;
 }(abstract_graph_1.AbstractEdge));
 exports.DirectedEdge = DirectedEdge;
@@ -373,8 +361,8 @@ var DirectedGraph = /** @class */ (function (_super) {
      * when stored with adjacency matrix time: O(V^2)
      * The `topologicalSort` function performs a topological sort on a graph and returns the sorted vertices in reverse
      * order, or null if the graph contains a cycle.
-     * @returns The `topologicalSort()` function returns an array of vertices (`V[]`) in topological order if there is no
-     * cycle in the graph. If there is a cycle, it returns `null`.
+     * @returns The function `topologicalSort()` returns an array of vertices in topological order if there is no cycle in
+     * the graph. If there is a cycle, it returns `null`.
      */
     DirectedGraph.prototype.topologicalSort = function () {
         var e_2, _a, e_3, _b;

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

@@ -30,11 +30,6 @@ export declare class UndirectedGraph<V extends UndirectedVertex, E extends Undir
     constructor();
     protected _edges: Map<V, E[]>;
     get edges(): Map<V, E[]>;
-    protected set edges(v: Map<V, E[]>);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getEdges(): Map<V, E[]>;
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
      * @param {V | null | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID
@@ -108,4 +103,5 @@ export declare class UndirectedGraph<V extends UndirectedVertex, E extends Undir
      * `null`.
      */
     getEndsOfEdge(edge: E): [V, V] | null;
+    protected _setEdges(v: Map<V, E[]>): void;
 }

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

@@ -119,18 +119,9 @@ var UndirectedGraph = /** @class */ (function (_super) {
         get: function () {
             return this._edges;
         },
-        set: function (v) {
-            this._edges = v;
-        },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    UndirectedGraph.prototype.getEdges = function () {
-        return this._edges;
-    };
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
      * @param {V | null | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID
@@ -327,6 +318,9 @@ var UndirectedGraph = /** @class */ (function (_super) {
             return null;
         }
     };
+    UndirectedGraph.prototype._setEdges = function (v) {
+        this._edges = v;
+    };
     return UndirectedGraph;
 }(abstract_graph_1.AbstractGraph));
 exports.UndirectedGraph = UndirectedGraph;

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

@@ -9,11 +9,6 @@ export declare class CoordinateMap<V> extends Map<any, V> {
     constructor(joint?: string);
     protected _joint: string;
     get joint(): string;
-    protected set joint(v: string);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getJoint(): string;
     /**
      * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
      * key array with a specified delimiter.
@@ -46,4 +41,5 @@ export declare class CoordinateMap<V> extends Map<any, V> {
      * `key` array joined together using the `_joint` property.
      */
     delete(key: number[]): boolean;
+    protected _setJoint(v: string): void;
 }

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

@@ -36,18 +36,9 @@ var CoordinateMap = /** @class */ (function (_super) {
         get: function () {
             return this._joint;
         },
-        set: function (v) {
-            this._joint = v;
-        },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    CoordinateMap.prototype.getJoint = function () {
-        return this._joint;
-    };
     /**
      * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
      * key array with a specified delimiter.
@@ -88,6 +79,9 @@ var CoordinateMap = /** @class */ (function (_super) {
     CoordinateMap.prototype.delete = function (key) {
         return _super.prototype.delete.call(this, key.join(this._joint));
     };
+    CoordinateMap.prototype._setJoint = function (v) {
+        this._joint = v;
+    };
     return CoordinateMap;
 }(Map));
 exports.CoordinateMap = CoordinateMap;

package/dist/data-structures/hash/coordinate-set.d.ts

@@ -9,11 +9,6 @@ export declare class CoordinateSet extends Set {
     constructor(joint?: string);
     protected _joint: string;
     get joint(): string;
-    protected set joint(v: string);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getJoint(): string;
     /**
      * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
      * joining its elements with a specified separator.
@@ -38,4 +33,5 @@ export declare class CoordinateSet extends Set {
      * `value` array joined together using the `_joint` property.
      */
     delete(value: number[]): boolean;
+    protected _setJoint(v: string): void;
 }

package/dist/data-structures/hash/coordinate-set.js

@@ -36,18 +36,9 @@ var CoordinateSet = /** @class */ (function (_super) {
         get: function () {
             return this._joint;
         },
-        set: function (v) {
-            this._joint = v;
-        },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    CoordinateSet.prototype.getJoint = function () {
-        return this._joint;
-    };
     /**
      * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
      * joining its elements with a specified separator.
@@ -78,6 +69,9 @@ var CoordinateSet = /** @class */ (function (_super) {
     CoordinateSet.prototype.delete = function (value) {
         return _super.prototype.delete.call(this, value.join(this._joint));
     };
+    CoordinateSet.prototype._setJoint = function (v) {
+        this._joint = v;
+    };
     return CoordinateSet;
 }(Set));
 exports.CoordinateSet = CoordinateSet;

package/dist/data-structures/hash/hash-table.d.ts

@@ -1 +1,2 @@
-export {};
+export declare class HashTable {
+}

package/dist/data-structures/hash/hash-table.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashTable = void 0;
+var HashTable = /** @class */ (function () {
+    function HashTable() {
+    }
+    return HashTable;
+}());
+exports.HashTable = HashTable;

package/dist/data-structures/hash/pair.d.ts

@@ -1 +1,2 @@
-export {};
+export declare class Pair {
+}

package/dist/data-structures/hash/pair.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pair = void 0;
+var Pair = /** @class */ (function () {
+    function Pair() {
+    }
+    return Pair;
+}());
+exports.Pair = Pair;