data-structure-typed 1.15.0 → 1.15.2

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

@@ -73,12 +73,6 @@ var BinaryTreeNode = /** @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.
-     */
-    BinaryTreeNode.prototype.getId = function () {
-        return this._id;
-    };
     Object.defineProperty(BinaryTreeNode.prototype, "val", {
         get: function () {
             return this._val;
@@ -89,12 +83,6 @@ var BinaryTreeNode = /** @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.
-     */
-    BinaryTreeNode.prototype.getVal = function () {
-        return this._val;
-    };
     Object.defineProperty(BinaryTreeNode.prototype, "left", {
         get: function () {
             return this._left;
@@ -109,12 +97,6 @@ var BinaryTreeNode = /** @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.
-     */
-    BinaryTreeNode.prototype.getLeft = function () {
-        return this._left;
-    };
     Object.defineProperty(BinaryTreeNode.prototype, "right", {
         get: function () {
             return this._right;
@@ -129,12 +111,6 @@ var BinaryTreeNode = /** @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.
-     */
-    BinaryTreeNode.prototype.getRight = function () {
-        return this._right;
-    };
     Object.defineProperty(BinaryTreeNode.prototype, "parent", {
         get: function () {
             return this._parent;
@@ -145,12 +121,6 @@ var BinaryTreeNode = /** @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.
-     */
-    BinaryTreeNode.prototype.getParent = function () {
-        return this._parent;
-    };
     Object.defineProperty(BinaryTreeNode.prototype, "familyPosition", {
         get: function () {
             return this._familyPosition;
@@ -161,12 +131,6 @@ var BinaryTreeNode = /** @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.
-     */
-    BinaryTreeNode.prototype.getFamilyPosition = function () {
-        return this._familyPosition;
-    };
     Object.defineProperty(BinaryTreeNode.prototype, "count", {
         get: function () {
             return this._count;
@@ -177,12 +141,6 @@ var BinaryTreeNode = /** @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.
-     */
-    BinaryTreeNode.prototype.getCount = function () {
-        return this._count;
-    };
     Object.defineProperty(BinaryTreeNode.prototype, "height", {
         get: function () {
             return this._height;
@@ -193,6 +151,48 @@ var BinaryTreeNode = /** @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.
+     */
+    BinaryTreeNode.prototype.getId = function () {
+        return this._id;
+    };
+    /**
+     * 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.
+     */
+    BinaryTreeNode.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.
+     */
+    BinaryTreeNode.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.
+     */
+    BinaryTreeNode.prototype.getRight = function () {
+        return this._right;
+    };
+    /**
+     * 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.
+     */
+    BinaryTreeNode.prototype.getParent = function () {
+        return this._parent;
+    };
+    /**
+     * 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.
+     */
+    BinaryTreeNode.prototype.getFamilyPosition = function () {
+        return this._familyPosition;
+    };
+    /**
+     * 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.
+     */
+    BinaryTreeNode.prototype.getCount = function () {
+        return this._count;
+    };
     /**
      * 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.
      */
@@ -261,13 +261,6 @@ var BinaryTree = /** @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 Getters (using the same name as the property) while utilizing separate method names for Setters.
-     * @returns The method is returning either a BinaryTreeNode object of type T or null.
-     */
-    BinaryTree.prototype.getRoot = function () {
-        return this._root;
-    };
     Object.defineProperty(BinaryTree.prototype, "size", {
         get: function () {
             return this._size;
@@ -278,12 +271,6 @@ var BinaryTree = /** @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.
-     */
-    BinaryTree.prototype.getSize = function () {
-        return this._size;
-    };
     Object.defineProperty(BinaryTree.prototype, "count", {
         get: function () {
             return this._count;
@@ -294,6 +281,19 @@ var BinaryTree = /** @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 Getters (using the same name as the property) while utilizing separate method names for Setters.
+     * @returns The method is returning either a BinaryTreeNode object of type T or null.
+     */
+    BinaryTree.prototype.getRoot = function () {
+        return this._root;
+    };
+    /**
+     * 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.
+     */
+    BinaryTree.prototype.getSize = function () {
+        return this._size;
+    };
     /**
      * 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.
      */

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

@@ -10,46 +10,46 @@ export declare class SegmentTreeNode {
     constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
     protected _start: number;
     get start(): number;
+    set start(v: number);
+    protected _end: number;
+    get end(): number;
+    set end(v: number);
+    protected _val: SegmentTreeNodeVal | null;
+    get val(): SegmentTreeNodeVal | null;
+    set val(v: SegmentTreeNodeVal | null);
+    protected _sum: number;
+    get sum(): number;
+    set sum(v: number);
+    protected _left: SegmentTreeNode | null;
+    get left(): SegmentTreeNode | null;
+    set left(v: SegmentTreeNode | null);
+    protected _right: SegmentTreeNode | null;
+    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;
-    set start(v: number);
-    protected _end: number;
-    get end(): 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;
-    set end(v: number);
-    protected _val: SegmentTreeNodeVal | null;
-    get val(): 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.
      */
     getVal(): SegmentTreeNodeVal | null;
-    set val(v: SegmentTreeNodeVal | null);
-    protected _sum: number;
-    get sum(): 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.
      */
     getSum(): number;
-    set sum(v: number);
-    protected _left: SegmentTreeNode | null;
-    get left(): 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.
      */
     getLeft(): SegmentTreeNode | null;
-    set left(v: SegmentTreeNode | null);
-    protected _right: SegmentTreeNode | null;
-    get right(): 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;
-    set right(v: SegmentTreeNode | null);
 }
 export declare class SegmentTree {
     protected _values: number[];
@@ -67,11 +67,11 @@ export declare class SegmentTree {
     constructor(values: number[], start?: number, end?: number);
     protected _root: SegmentTreeNode | null;
     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;
-    set root(v: SegmentTreeNode | null);
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
      * for each segment.

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

@@ -31,12 +31,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;
-    };
     Object.defineProperty(SegmentTreeNode.prototype, "end", {
         get: function () {
             return this._end;
@@ -47,12 +41,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.getEnd = function () {
-        return this._end;
-    };
     Object.defineProperty(SegmentTreeNode.prototype, "val", {
         get: function () {
             return this._val;
@@ -63,12 +51,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.getVal = function () {
-        return this._val;
-    };
     Object.defineProperty(SegmentTreeNode.prototype, "sum", {
         get: function () {
             return this._sum;
@@ -79,12 +61,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.getSum = function () {
-        return this._sum;
-    };
     Object.defineProperty(SegmentTreeNode.prototype, "left", {
         get: function () {
             return this._left;
@@ -95,12 +71,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.getLeft = function () {
-        return this._left;
-    };
     Object.defineProperty(SegmentTreeNode.prototype, "right", {
         get: function () {
             return this._right;
@@ -111,6 +81,36 @@ 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.
      */

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

@@ -1,13 +1,13 @@
 import type { DijkstraResult, IGraph, VertexId } from '../types';
 export declare class AbstractVertex {
+    constructor(id: VertexId);
     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;
-    set id(v: VertexId);
-    constructor(id: VertexId);
 }
 export declare abstract class AbstractEdge {
     static DEFAULT_EDGE_WEIGHT: number;
@@ -19,18 +19,18 @@ export declare abstract class AbstractEdge {
     protected constructor(weight?: number);
     private _weight;
     get weight(): number;
+    set weight(v: number);
+    private _hashCode;
+    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;
-    set weight(v: number);
-    private _hashCode;
-    get hashCode(): 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.
      */
     getHashCode(): string;
-    set hashCode(v: string);
 }
 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

@@ -91,12 +91,6 @@ var AbstractEdge = /** @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.
-     */
-    AbstractEdge.prototype.getWeight = function () {
-        return this._weight;
-    };
     Object.defineProperty(AbstractEdge.prototype, "hashCode", {
         get: function () {
             return this._hashCode;
@@ -107,6 +101,12 @@ var AbstractEdge = /** @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.
+     */
+    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.
      */

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

@@ -21,18 +21,18 @@ export declare class DirectedEdge extends AbstractEdge {
     constructor(src: VertexId, dest: VertexId, weight?: number);
     private _src;
     get src(): VertexId;
+    set src(v: VertexId);
+    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;
-    set src(v: VertexId);
-    private _dest;
-    get dest(): 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;
-    set dest(v: VertexId);
 }
 export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
     protected _outEdgeMap: Map<V, E[]>;

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

@@ -101,12 +101,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;
-    };
     Object.defineProperty(DirectedEdge.prototype, "dest", {
         get: function () {
             return this._dest;
@@ -117,6 +111,12 @@ 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.
      */

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

@@ -20,21 +20,21 @@ export declare class UndirectedEdge extends AbstractEdge {
     constructor(v1: VertexId, v2: VertexId, weight?: number);
     private _vertices;
     get vertices(): [VertexId, VertexId];
+    set vertices(v: [VertexId, 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.
      */
     getVertices(): [VertexId, VertexId];
-    set vertices(v: [VertexId, VertexId]);
 }
 export declare class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
+    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[]>;
-    protected set edges(v: Map<V, E[]>);
-    constructor();
     /**
      * 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

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

@@ -6,14 +6,14 @@
  * @license MIT License
  */
 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;
-    protected set joint(v: string);
-    constructor(joint?: 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.

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

@@ -6,14 +6,14 @@
  * @license MIT License
  */
 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;
-    protected set joint(v: string);
-    constructor(joint?: 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.

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

@@ -8,31 +8,31 @@
 import { PriorityQueue } from '../priority-queue';
 import type { HeapItem, HeapOptions } from '../types';
 export declare abstract class Heap<T> {
-    protected abstract _pq: PriorityQueue<HeapItem<T>>;
-    get pq(): PriorityQueue<HeapItem<T>>;
-    /**
-     * 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.
-     */
-    getPq(): PriorityQueue<HeapItem<T>>;
-    protected set pq(v: PriorityQueue<HeapItem<T>>);
-    protected _priorityCb: (element: T) => number;
-    get priorityCb(): (element: T) => 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.
-     */
-    getPriorityCb(): (element: T) => number;
-    protected set priorityCb(v: (element: T) => number);
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
      * options provided.
      * @param [options] - An optional object that contains configuration options for the Heap.
      */
     protected constructor(options?: HeapOptions<T>);
+    protected abstract _pq: PriorityQueue<HeapItem<T>>;
+    get pq(): PriorityQueue<HeapItem<T>>;
+    protected set pq(v: PriorityQueue<HeapItem<T>>);
+    protected _priorityCb: (element: T) => number;
+    get priorityCb(): (element: T) => number;
+    protected set priorityCb(v: (element: T) => number);
     /**
      * The function returns the size of a priority queue.
      * @returns The size of the priority queue.
      */
     get size(): 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.
+     */
+    getPq(): PriorityQueue<HeapItem<T>>;
+    /**
+     * 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.
+     */
+    getPriorityCb(): (element: T) => 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.
      */

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

@@ -29,12 +29,6 @@ var Heap = /** @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.
-     */
-    Heap.prototype.getPq = function () {
-        return this._pq;
-    };
     Object.defineProperty(Heap.prototype, "priorityCb", {
         get: function () {
             return this._priorityCb;
@@ -45,12 +39,6 @@ var Heap = /** @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.
-     */
-    Heap.prototype.getPriorityCb = function () {
-        return this._priorityCb;
-    };
     Object.defineProperty(Heap.prototype, "size", {
         /**
          * The function returns the size of a priority queue.
@@ -62,6 +50,18 @@ var Heap = /** @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.
+     */
+    Heap.prototype.getPq = function () {
+        return this._pq;
+    };
+    /**
+     * 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.
+     */
+    Heap.prototype.getPriorityCb = function () {
+        return this._priorityCb;
+    };
     /**
      * 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.
      */