data-structure-typed 1.15.1 → 1.15.2

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

@@ -30,15 +30,15 @@ export enum LoopType { iterative = 1, recursive = 2}
 
 export class BinaryTreeNode<T> {
 
-    protected _id: BinaryTreeNodeId;
-    get id(): BinaryTreeNodeId {
-        return this._id;
+    constructor(id: BinaryTreeNodeId, val: T, count?: number) {
+        this._id = id;
+        this._val = val;
+        this._count = count ?? 1;
     }
 
-    /**
-     * 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(): BinaryTreeNodeId {
+    protected _id: BinaryTreeNodeId;
+
+    get id(): BinaryTreeNodeId {
         return this._id;
     }
 
@@ -51,26 +51,13 @@ export class BinaryTreeNode<T> {
         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.
-     */
-    getVal(): T {
-        return this._val;
-    }
-
     set val(v: T) {
         this._val = v;
     }
 
     protected _left?: BinaryTreeNode<T> | null;
-    get left(): BinaryTreeNode<T> | null | undefined {
-        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.
-     */
-    getLeft(): BinaryTreeNode<T> | null | undefined {
+    get left(): BinaryTreeNode<T> | null | undefined {
         return this._left;
     }
 
@@ -83,14 +70,8 @@ export class BinaryTreeNode<T> {
     }
 
     protected _right?: BinaryTreeNode<T> | null;
-    get right(): BinaryTreeNode<T> | null | undefined {
-        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.
-     */
-    getRight(): BinaryTreeNode<T> | null | undefined {
+    get right(): BinaryTreeNode<T> | null | undefined {
         return this._right;
     }
 
@@ -103,14 +84,8 @@ export class BinaryTreeNode<T> {
     }
 
     protected _parent: BinaryTreeNode<T> | null | undefined;
-    get parent(): BinaryTreeNode<T> | null | undefined {
-        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.
-     */
-    getParent(): BinaryTreeNode<T> | null | undefined {
+    get parent(): BinaryTreeNode<T> | null | undefined {
         return this._parent;
     }
 
@@ -119,14 +94,8 @@ export class BinaryTreeNode<T> {
     }
 
     protected _familyPosition: FamilyPosition = FamilyPosition.root;
-    get familyPosition(): FamilyPosition {
-        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.
-     */
-    getFamilyPosition(): FamilyPosition {
+    get familyPosition(): FamilyPosition {
         return this._familyPosition;
     }
 
@@ -135,14 +104,8 @@ export class BinaryTreeNode<T> {
     }
 
     protected _count = 1;
-    get count(): number {
-        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.
-     */
-    getCount(): number {
+    get count(): number {
         return this._count;
     }
 
@@ -151,25 +114,69 @@ export class BinaryTreeNode<T> {
     }
 
     protected _height = 0;
+
     get height(): number {
         return this._height;
     }
 
+    set height(v: number) {
+        this._height = v;
+    }
+
     /**
      * 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.
      */
-    getHeight(): number {
-        return this._height;
+    getId(): BinaryTreeNodeId {
+        return this._id;
     }
 
-    set height(v: number) {
-        this._height = v;
+    /**
+     * 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(): T {
+        return this._val;
     }
 
-    constructor(id: BinaryTreeNodeId, val: T, count?: number) {
-        this._id = id;
-        this._val = val;
-        this._count = count ?? 1;
+    /**
+     * 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(): BinaryTreeNode<T> | null | undefined {
+        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.
+     */
+    getRight(): BinaryTreeNode<T> | null | undefined {
+        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.
+     */
+    getParent(): BinaryTreeNode<T> | null | undefined {
+        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.
+     */
+    getFamilyPosition(): FamilyPosition {
+        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.
+     */
+    getCount(): number {
+        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.
+     */
+    getHeight(): number {
+        return this._height;
     }
 
     swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T> {
@@ -235,14 +242,6 @@ export class BinaryTree<T> {
         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 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.
-     */
-    getRoot(): BinaryTreeNode<T> | null {
-        return this._root;
-    }
-
     protected set root(v: BinaryTreeNode<T> | null) {
         if (v) {
             v.parent = null;
@@ -257,13 +256,6 @@ export class BinaryTree<T> {
         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.
-     */
-    getSize(): number {
-        return this._size;
-    }
-
     protected set size(v: number) {
         this._size = v;
     }
@@ -274,15 +266,30 @@ export class BinaryTree<T> {
         return this._count;
     }
 
+    protected set count(v: number) {
+        this._count = v;
+    }
+
+    /**
+     * 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.
+     */
+    getRoot(): BinaryTreeNode<T> | null {
+        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.
      */
-    getCount(): number {
-        return this._count;
+    getSize(): number {
+        return this._size;
     }
 
-    protected set count(v: number) {
-        this._count = v;
+    /**
+     * 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.
+     */
+    getCount(): number {
+        return this._count;
     }
 
     /**

package/src/data-structures/binary-tree/segment-tree.ts

@@ -20,85 +20,102 @@ export class SegmentTreeNode {
     get start(): number {
         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.
-     */
-    getStart(): number {
-        return this._start;
-    }
+
     set start(v: number) {
         this._start = v;
     }
 
     protected _end = 0;
+
     get end(): number {
         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.
-     */
-    getEnd(): number {
-        return this._end;
-    }
+
     set end(v: number) {
         this._end = v;
     }
 
     protected _val: SegmentTreeNodeVal | null = null;
+
     get val(): SegmentTreeNodeVal | null {
         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.
-     */
-    getVal(): SegmentTreeNodeVal | null {
-        return this._val;
-    }
+
     set val(v: SegmentTreeNodeVal | null) {
         this._val = v;
     }
 
     protected _sum = 0;
+
     get sum(): number {
         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.
-     */
-    getSum(): number {
-        return this._sum;
-    }
+
     set sum(v: number) {
         this._sum = v;
     }
 
     protected _left: SegmentTreeNode | null = null;
+
     get left(): SegmentTreeNode | null {
         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.
-     */
-    getLeft(): SegmentTreeNode | null {
-        return this._left;
-    }
+
     set left(v: SegmentTreeNode | null) {
         this._left = v;
     }
 
     protected _right: SegmentTreeNode | null = null;
+
     get right(): SegmentTreeNode | null {
         return this._right;
     }
+
+    set right(v: SegmentTreeNode | null) {
+        this._right = v;
+    }
+
+    /**
+     * 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 {
+        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.
+     */
+    getEnd(): number {
+        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.
+     */
+    getVal(): SegmentTreeNodeVal | null {
+        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.
+     */
+    getSum(): number {
+        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.
+     */
+    getLeft(): SegmentTreeNode | null {
+        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.
      */
     getRight(): SegmentTreeNode | null {
         return this._right;
     }
-    set right(v: SegmentTreeNode | null) {
-        this._right = v;
-    }
 }
 
 export class SegmentTree {
@@ -128,15 +145,17 @@ export class SegmentTree {
     get root(): SegmentTreeNode | null {
         return this._root;
     }
+
+    set root(v: SegmentTreeNode | null) {
+        this._root = v;
+    }
+
     /**
      * 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 {
         return this._root;
     }
-    set root(v: SegmentTreeNode | null) {
-        this._root = v;
-    }
 
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes

package/src/data-structures/graph/abstract-graph.ts

@@ -10,25 +10,26 @@ import {PriorityQueue} from '../priority-queue';
 import type {DijkstraResult, IGraph, VertexId} from '../types';
 
 export class AbstractVertex {
+    constructor(id: VertexId) {
+        this._id = id;
+    }
+
     protected _id: VertexId;
+
     get id(): VertexId {
         return this._id;
     }
 
+    set id(v: VertexId) {
+        this._id = v;
+    }
+
     /**
      * 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 {
         return this._id;
     }
-
-    set id(v: VertexId) {
-        this._id = v;
-    }
-
-    constructor(id: VertexId) {
-        this._id = id;
-    }
 }
 
 export abstract class AbstractEdge {
@@ -51,31 +52,32 @@ export abstract class AbstractEdge {
         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.
-     */
-    getWeight(): number {
-        return this._weight;
-    }
-
     set weight(v: number) {
         this._weight = v;
     }
 
     private _hashCode: string;
+
     get hashCode(): string {
         return this._hashCode;
     }
 
+    set hashCode(v: string) {
+        this._hashCode = v;
+    }
+
     /**
      * 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 {
-        return this._hashCode;
+    getWeight(): number {
+        return this._weight;
     }
 
-    set hashCode(v: string) {
-        this._hashCode = v;
+    /**
+     * 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 {
+        return this._hashCode;
     }
 }
 

package/src/data-structures/graph/directed-graph.ts

@@ -40,29 +40,34 @@ export class DirectedEdge extends AbstractEdge {
     get src(): VertexId {
         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.
-     */
-    getSrc(): VertexId {
-        return this._src;
-    }
+
     set src(v: VertexId) {
         this._src = v;
     }
 
     private _dest: VertexId;
+
     get dest(): VertexId {
         return this._dest;
     }
+
+    set dest(v: VertexId) {
+        this._dest = v;
+    }
+
+    /**
+     * 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 {
+        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.
      */
     getDest(): VertexId {
         return this._dest;
     }
-    set dest(v: VertexId) {
-        this._dest = v;
-    }
 }
 
 // Strongly connected, One direction connected, Weakly connected
@@ -159,14 +164,14 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
 
         const srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges) {
-    /**
-     * The removeEdge function removes an edge from a graph and returns the removed edge, or null if the edge was not
-     * found.
-     * @param {E} edge - The `edge` parameter represents the edge that you want to remove from the graph. It should be an
-     * object that has `src` and `dest` properties, which represent the source and destination vertices of the edge,
-     * respectively.
-     * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
-     */
+            /**
+             * The removeEdge function removes an edge from a graph and returns the removed edge, or null if the edge was not
+             * found.
+             * @param {E} edge - The `edge` parameter represents the edge that you want to remove from the graph. It should be an
+             * object that has `src` and `dest` properties, which represent the source and destination vertices of the edge,
+             * respectively.
+             * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+             */
             arrayRemove<E>(srcOutEdges, (edge: DirectedEdge) => edge.dest === dest.id);
         }
 
@@ -184,7 +189,7 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
      * and `dest`, which represent the source and destination vertices of the edge, respectively.
      * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
      */
-    removeEdge(edge: E ): E | null {
+    removeEdge(edge: E): E | null {
         let removed: E | null = null;
         const src = this.getVertex(edge.src);
         const dest = this.getVertex(edge.dest);

package/src/data-structures/graph/undirected-graph.ts

@@ -38,36 +38,41 @@ export class UndirectedEdge extends AbstractEdge {
     get vertices() {
         return this._vertices;
     }
+
+    set vertices(v: [VertexId, VertexId]) {
+        this._vertices = v;
+    }
+
     /**
      * 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() {
         return this._vertices;
     }
-    set vertices(v: [VertexId, VertexId]) {
-        this._vertices = v;
-    }
 }
 
 export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
+    constructor() {
+        super();
+        this._edges = new Map<V, E[]>();
+    }
+
     protected _edges: Map<V, E[]>;
+
     get edges(): Map<V, E[]> {
         return this._edges;
     }
+
+    protected set edges(v: Map<V, E[]>) {
+        this._edges = v;
+    }
+
     /**
      * 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[]> {
         return this._edges;
     }
-    protected set edges(v: Map<V, E[]>) {
-        this._edges = v;
-    }
-
-    constructor() {
-        super();
-        this._edges = new Map<V, E[]>();
-    }
 
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.

package/src/data-structures/hash/coordinate-map.ts

@@ -6,24 +6,27 @@
  * @license MIT License
  */
 export class CoordinateMap<V> extends Map<any, V> {
+    constructor(joint?: string) {
+        super();
+        if (joint !== undefined) this._joint = joint;
+    }
+
     protected _joint: string = '_';
+
     get joint(): string {
         return this._joint;
     }
+
+    protected set joint(v: string) {
+        this._joint = v;
+    }
+
     /**
      * 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 {
         return this._joint;
     }
-    protected set joint(v: string) {
-        this._joint = v;
-    }
-
-    constructor(joint?: string) {
-        super();
-        if (joint !== undefined) this._joint = joint;
-    }
 
     /**
      * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the