data-structure-typed 1.39.6 → 1.40.0

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

@@ -62,7 +62,7 @@ class BST extends binary_tree_1.BinaryTree {
         }
         if (this.root === null) {
             this._setRoot(newNode);
-            this._setSize(this.size + 1);
+            this._size = this.size + 1;
             inserted = this.root;
         }
         else {
@@ -86,7 +86,7 @@ class BST extends binary_tree_1.BinaryTree {
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
-                            this._setSize(this.size + 1);
+                            this._size = this.size + 1;
                             traversing = false;
                             inserted = cur.left;
                         }
@@ -104,7 +104,7 @@ class BST extends binary_tree_1.BinaryTree {
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
-                            this._setSize(this.size + 1);
+                            this._size = this.size + 1;
                             traversing = false;
                             inserted = cur.right;
                         }

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

@@ -3,9 +3,7 @@ import { IBinaryTree } from '../../interfaces';
 import { BST, BSTNode } from './bst';
 export declare class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
     constructor(key: BTNKey, value?: V);
-    private _color;
-    get color(): RBColor;
-    set color(value: RBColor);
+    color: RBColor;
 }
 export declare class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
     constructor(options?: RBTreeOptions);

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

@@ -6,15 +6,9 @@ const bst_1 = require("./bst");
 class RBTreeNode extends bst_1.BSTNode {
     constructor(key, value) {
         super(key, value);
-        this._color = types_1.RBColor.RED;
-    }
-    _color;
-    get color() {
-        return this._color;
-    }
-    set color(value) {
-        this._color = value;
+        this.color = types_1.RBColor.RED;
     }
+    color;
 }
 exports.RBTreeNode = RBTreeNode;
 class RBTree extends bst_1.BST {

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

@@ -7,25 +7,13 @@
  */
 import type { SegmentTreeNodeVal } from '../../types';
 export declare class SegmentTreeNode {
+    start: number;
+    end: number;
+    value: SegmentTreeNodeVal | null;
+    sum: number;
+    left: SegmentTreeNode | null;
+    right: SegmentTreeNode | null;
     constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null);
-    private _start;
-    get start(): number;
-    set start(v: number);
-    private _end;
-    get end(): number;
-    set end(v: number);
-    private _value;
-    get value(): SegmentTreeNodeVal | null;
-    set value(v: SegmentTreeNodeVal | null);
-    private _sum;
-    get sum(): number;
-    set sum(v: number);
-    private _left;
-    get left(): SegmentTreeNode | null;
-    set left(v: SegmentTreeNode | null);
-    private _right;
-    get right(): SegmentTreeNode | null;
-    set right(v: SegmentTreeNode | null);
 }
 export declare class SegmentTree {
     /**
@@ -38,13 +26,13 @@ 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);
-    private _values;
+    protected _values: number[];
     get values(): number[];
-    private _start;
+    protected _start: number;
     get start(): number;
-    private _end;
+    protected _end: number;
     get end(): number;
-    private _root;
+    protected _root: SegmentTreeNode | null;
     get root(): SegmentTreeNode | null;
     /**
      * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
@@ -76,8 +64,4 @@ 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/mjs/data-structures/binary-tree/segment-tree.js

@@ -9,53 +9,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentTree = exports.SegmentTreeNode = void 0;
 class SegmentTreeNode {
+    start = 0;
+    end = 0;
+    value = null;
+    sum = 0;
+    left = null;
+    right = null;
     constructor(start, end, sum, value) {
-        this._start = start;
-        this._end = end;
-        this._sum = sum;
-        this._value = value || null;
-    }
-    _start = 0;
-    get start() {
-        return this._start;
-    }
-    set start(v) {
-        this._start = v;
-    }
-    _end = 0;
-    get end() {
-        return this._end;
-    }
-    set end(v) {
-        this._end = v;
-    }
-    _value = null;
-    get value() {
-        return this._value;
-    }
-    set value(v) {
-        this._value = v;
-    }
-    _sum = 0;
-    get sum() {
-        return this._sum;
-    }
-    set sum(v) {
-        this._sum = v;
-    }
-    _left = null;
-    get left() {
-        return this._left;
-    }
-    set left(v) {
-        this._left = v;
-    }
-    _right = null;
-    get right() {
-        return this._right;
-    }
-    set right(v) {
-        this._right = v;
+        this.start = start;
+        this.end = end;
+        this.sum = sum;
+        this.value = value || null;
     }
 }
 exports.SegmentTreeNode = SegmentTreeNode;
@@ -214,17 +178,5 @@ class SegmentTree {
         };
         return dfs(root, indexA, indexB);
     }
-    _setValues(value) {
-        this._values = value;
-    }
-    _setStart(value) {
-        this._start = value;
-    }
-    _setEnd(value) {
-        this._end = value;
-    }
-    _setRoot(v) {
-        this._root = v;
-    }
 }
 exports.SegmentTree = SegmentTree;

package/dist/mjs/data-structures/binary-tree/tree-multiset.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BTNKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, IterationType, BTNCallback } from '../../types';
+import { BinaryTreeDeletedResult, BTNCallback, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, N> {

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

@@ -76,7 +76,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         }
         if (!this.root) {
             this._setRoot(newNode);
-            this._setSize(this.size + 1);
+            this._size = this.size + 1;
             newNode && this._setCount(this.count + newNode.count);
             inserted = this.root;
         }
@@ -98,7 +98,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                             if (cur.left === undefined) {
                                 //Add to the left of the current node
                                 cur.left = newNode;
-                                this._setSize(this.size + 1);
+                                this._size = this.size + 1;
                                 this._setCount(this.count + newNode.count);
                                 traversing = false;
                                 inserted = cur.left;
@@ -114,7 +114,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                             if (cur.right === undefined) {
                                 //Add to the right of the current node
                                 cur.right = newNode;
-                                this._setSize(this.size + 1);
+                                this._size = this.size + 1;
                                 this._setCount(this.count + newNode.count);
                                 traversing = false;
                                 inserted = cur.right;
@@ -152,7 +152,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             if (parent.left === undefined) {
                 parent.left = newNode;
                 if (newNode !== null) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.left;
@@ -160,7 +160,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             else if (parent.right === undefined) {
                 parent.right = newNode;
                 if (newNode !== null) {
-                    this._setSize(this.size + 1);
+                    this._size = (this.size + 1);
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.right;
@@ -305,7 +305,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     }
                 }
             }
-            this._setSize(this.size - 1);
+            this._size = this.size - 1;
             // TODO How to handle when the count of target node is lesser than current node's count
             this._setCount(this.count - orgCurrent.count);
         }

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

@@ -1,6 +1,8 @@
 import type { DijkstraResult, VertexKey } from '../../types';
 import { IGraph } from '../../interfaces';
 export declare abstract class AbstractVertex<V = any> {
+    key: VertexKey;
+    value: V | undefined;
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
@@ -9,14 +11,10 @@ export declare abstract class AbstractVertex<V = any> {
      * vertex. If no value is provided, it will be set to undefined.
      */
     protected constructor(key: VertexKey, value?: V);
-    private _key;
-    get key(): VertexKey;
-    set key(v: VertexKey);
-    private _value;
-    get value(): V | undefined;
-    set value(value: V | undefined);
 }
 export declare abstract class AbstractEdge<E = any> {
+    value: E | undefined;
+    weight: number;
     /**
      * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
      * object.
@@ -27,27 +25,11 @@ export declare abstract class AbstractEdge<E = any> {
      * meaning it can be omitted when creating an instance of the class.
      */
     protected constructor(weight?: number, value?: E);
-    private _value;
-    get value(): E | undefined;
-    set value(value: E | undefined);
-    private _weight;
-    get weight(): number;
-    set weight(v: number);
     protected _hashCode: string;
     get hashCode(): string;
-    /**
-     * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
-     * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
-     */
-    /**
-     * The function sets the value of the _hashCode property to the provided string.
-     * @param {string} v - The parameter "v" is of type string and represents the value that will be assigned to the
-     * "_hashCode" property.
-     */
-    protected _setHashCode(v: string): void;
 }
 export declare abstract class AbstractGraph<V = any, E = any, VO extends AbstractVertex<V> = AbstractVertex<V>, EO extends AbstractEdge<E> = AbstractEdge<E>> implements IGraph<V, E, VO, EO> {
-    private _vertices;
+    protected _vertices: Map<VertexKey, VO>;
     get vertices(): Map<VertexKey, VO>;
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
@@ -328,5 +310,4 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     protected _addVertexOnly(newVertex: VO): boolean;
     protected _getVertex(vertexOrKey: VertexKey | VO): VO | null;
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
-    protected _setVertices(value: Map<VertexKey, VO>): void;
 }

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

@@ -12,6 +12,8 @@ const utils_1 = require("../../utils");
 const priority_queue_1 = require("../priority-queue");
 const queue_1 = require("../queue");
 class AbstractVertex {
+    key;
+    value;
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
@@ -20,26 +22,14 @@ class AbstractVertex {
      * vertex. If no value is provided, it will be set to undefined.
      */
     constructor(key, value) {
-        this._key = key;
-        this._value = value;
-    }
-    _key;
-    get key() {
-        return this._key;
-    }
-    set key(v) {
-        this._key = v;
-    }
-    _value;
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
+        this.key = key;
+        this.value = value;
     }
 }
 exports.AbstractVertex = AbstractVertex;
 class AbstractEdge {
+    value;
+    weight;
     /**
      * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
      * object.
@@ -50,40 +40,14 @@ class AbstractEdge {
      * meaning it can be omitted when creating an instance of the class.
      */
     constructor(weight, value) {
-        this._weight = weight !== undefined ? weight : 1;
-        this._value = value;
+        this.weight = weight !== undefined ? weight : 1;
+        this.value = value;
         this._hashCode = (0, utils_1.uuidV4)();
     }
-    _value;
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    _weight;
-    get weight() {
-        return this._weight;
-    }
-    set weight(v) {
-        this._weight = v;
-    }
     _hashCode;
     get hashCode() {
         return this._hashCode;
     }
-    /**
-     * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
-     * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
-     */
-    /**
-     * The function sets the value of the _hashCode property to the provided string.
-     * @param {string} v - The parameter "v" is of type string and represents the value that will be assigned to the
-     * "_hashCode" property.
-     */
-    _setHashCode(v) {
-        this._hashCode = v;
-    }
 }
 exports.AbstractEdge = AbstractEdge;
 class AbstractGraph {
@@ -915,8 +879,5 @@ class AbstractGraph {
     _getVertexKey(vertexOrKey) {
         return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
     }
-    _setVertices(value) {
-        this._vertices = value;
-    }
 }
 exports.AbstractGraph = AbstractGraph;

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

@@ -12,6 +12,8 @@ export declare class DirectedVertex<V = any> extends AbstractVertex<V> {
     constructor(key: VertexKey, value?: V);
 }
 export declare class DirectedEdge<E = any> extends AbstractEdge<E> {
+    src: VertexKey;
+    dest: VertexKey;
     /**
      * The constructor function initializes the source and destination vertices of an edge, along with an optional weight
      * and value.
@@ -24,21 +26,15 @@ export declare class DirectedEdge<E = any> extends AbstractEdge<E> {
      * the edge.
      */
     constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E);
-    private _src;
-    get src(): VertexKey;
-    set src(v: VertexKey);
-    private _dest;
-    get dest(): VertexKey;
-    set dest(v: VertexKey);
 }
 export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V> = DirectedVertex<V>, EO extends DirectedEdge<E> = DirectedEdge<E>> extends AbstractGraph<V, E, VO, EO> implements IGraph<V, E, VO, EO> {
     /**
      * The constructor function initializes an instance of a class.
      */
     constructor();
-    private _outEdgeMap;
+    protected _outEdgeMap: Map<VO, EO[]>;
     get outEdgeMap(): Map<VO, EO[]>;
-    private _inEdgeMap;
+    protected _inEdgeMap: Map<VO, EO[]>;
     get inEdgeMap(): Map<VO, EO[]>;
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
@@ -195,6 +191,4 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * source or destination vertex does not exist in the graph.
      */
     protected _addEdgeOnly(edge: EO): boolean;
-    protected _setOutEdgeMap(value: Map<VO, EO[]>): void;
-    protected _setInEdgeMap(value: Map<VO, EO[]>): void;
 }

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

@@ -24,6 +24,8 @@ class DirectedVertex extends abstract_graph_1.AbstractVertex {
 }
 exports.DirectedVertex = DirectedVertex;
 class DirectedEdge extends abstract_graph_1.AbstractEdge {
+    src;
+    dest;
     /**
      * The constructor function initializes the source and destination vertices of an edge, along with an optional weight
      * and value.
@@ -37,22 +39,8 @@ class DirectedEdge extends abstract_graph_1.AbstractEdge {
      */
     constructor(src, dest, weight, value) {
         super(weight, value);
-        this._src = src;
-        this._dest = dest;
-    }
-    _src;
-    get src() {
-        return this._src;
-    }
-    set src(v) {
-        this._src = v;
-    }
-    _dest;
-    get dest() {
-        return this._dest;
-    }
-    set dest(v) {
-        this._dest = v;
+        this.src = src;
+        this.dest = dest;
     }
 }
 exports.DirectedEdge = DirectedEdge;
@@ -414,11 +402,5 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
             return false;
         }
     }
-    _setOutEdgeMap(value) {
-        this._outEdgeMap = value;
-    }
-    _setInEdgeMap(value) {
-        this._inEdgeMap = value;
-    }
 }
 exports.DirectedGraph = DirectedGraph;

package/dist/mjs/data-structures/graph/map-graph.d.ts

@@ -1,6 +1,8 @@
 import { MapGraphCoordinate, VertexKey } from '../../types';
 import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
 export declare class MapVertex<V = any> extends DirectedVertex<V> {
+    lat: number;
+    long: number;
     /**
      * The constructor function initializes an object with an key, latitude, longitude, and an optional value.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex.
@@ -14,12 +16,6 @@ export declare class MapVertex<V = any> extends DirectedVertex<V> {
      * creating an instance of the class.
      */
     constructor(key: VertexKey, value: V, lat: number, long: number);
-    private _lat;
-    get lat(): number;
-    set lat(value: number);
-    private _long;
-    get long(): number;
-    set long(value: number);
 }
 export declare class MapEdge<E = any> extends DirectedEdge<E> {
     /**
@@ -45,12 +41,10 @@ export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVer
      * it will default to `undefined`.
      */
     constructor(origin: MapGraphCoordinate, bottomRight?: MapGraphCoordinate);
-    private _origin;
+    protected _origin: MapGraphCoordinate;
     get origin(): MapGraphCoordinate;
-    set origin(value: MapGraphCoordinate);
-    private _bottomRight;
+    protected _bottomRight: MapGraphCoordinate | undefined;
     get bottomRight(): MapGraphCoordinate | undefined;
-    set bottomRight(value: MapGraphCoordinate | undefined);
     /**
      * The function creates a new vertex with the given key, value, latitude, and longitude.
      * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could

package/dist/mjs/data-structures/graph/map-graph.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MapGraph = exports.MapEdge = exports.MapVertex = void 0;
 const directed_graph_1 = require("./directed-graph");
 class MapVertex extends directed_graph_1.DirectedVertex {
+    lat;
+    long;
     /**
      * The constructor function initializes an object with an key, latitude, longitude, and an optional value.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex.
@@ -17,22 +19,8 @@ class MapVertex extends directed_graph_1.DirectedVertex {
      */
     constructor(key, value, lat, long) {
         super(key, value);
-        this._lat = lat;
-        this._long = long;
-    }
-    _lat;
-    get lat() {
-        return this._lat;
-    }
-    set lat(value) {
-        this._lat = value;
-    }
-    _long;
-    get long() {
-        return this._long;
-    }
-    set long(value) {
-        this._long = value;
+        this.lat = lat;
+        this.long = long;
     }
 }
 exports.MapVertex = MapVertex;
@@ -71,16 +59,10 @@ class MapGraph extends directed_graph_1.DirectedGraph {
     get origin() {
         return this._origin;
     }
-    set origin(value) {
-        this._origin = value;
-    }
     _bottomRight;
     get bottomRight() {
         return this._bottomRight;
     }
-    set bottomRight(value) {
-        this._bottomRight = value;
-    }
     /**
      * The function creates a new vertex with the given key, value, latitude, and longitude.
      * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could

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

@@ -12,6 +12,7 @@ export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     constructor(key: VertexKey, value?: V);
 }
 export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
+    vertices: [VertexKey, VertexKey];
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -23,9 +24,6 @@ export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
      * with the edge.
      */
     constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E);
-    private _vertices;
-    get vertices(): [VertexKey, VertexKey];
-    set vertices(v: [VertexKey, VertexKey]);
 }
 export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVertex<V> = UndirectedVertex<V>, EO extends UndirectedEdge<E> = UndirectedEdge<E>> extends AbstractGraph<V, E, VO, EO> implements IGraph<V, E, VO, EO> {
     /**
@@ -119,9 +117,4 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @returns a boolean value.
      */
     protected _addEdgeOnly(edge: EO): boolean;
-    /**
-     * The function sets the edges of a graph.
-     * @param v - A map where the keys are of type VO and the values are arrays of type EO.
-     */
-    protected _setEdges(v: Map<VO, EO[]>): void;
 }

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

@@ -24,6 +24,7 @@ class UndirectedVertex extends abstract_graph_1.AbstractVertex {
 }
 exports.UndirectedVertex = UndirectedVertex;
 class UndirectedEdge extends abstract_graph_1.AbstractEdge {
+    vertices;
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -36,14 +37,7 @@ class UndirectedEdge extends abstract_graph_1.AbstractEdge {
      */
     constructor(v1, v2, weight, value) {
         super(weight, value);
-        this._vertices = [v1, v2];
-    }
-    _vertices;
-    get vertices() {
-        return this._vertices;
-    }
-    set vertices(v) {
-        this._vertices = v;
+        this.vertices = [v1, v2];
     }
 }
 exports.UndirectedEdge = UndirectedEdge;
@@ -241,12 +235,5 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
         }
         return true;
     }
-    /**
-     * The function sets the edges of a graph.
-     * @param v - A map where the keys are of type VO and the values are arrays of type EO.
-     */
-    _setEdges(v) {
-        this._edges = v;
-    }
 }
 exports.UndirectedGraph = UndirectedGraph;

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

@@ -41,5 +41,4 @@ 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/mjs/data-structures/hash/coordinate-map.js

@@ -58,8 +58,5 @@ class CoordinateMap extends Map {
     delete(key) {
         return super.delete(key.join(this._joint));
     }
-    _setJoint(v) {
-        this._joint = v;
-    }
 }
 exports.CoordinateMap = CoordinateMap;

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

@@ -33,5 +33,4 @@ export declare class CoordinateSet extends Set<any> {
      * `value` array joined together using the `_joint` property.
      */
     delete(value: number[]): boolean;
-    protected _setJoint(v: string): void;
 }