min-heap-typed 1.39.5 → 1.39.6

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

@@ -8,14 +8,14 @@ class TreeMultisetNode extends avl_tree_1.AVLTreeNode {
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
      * of the binary tree node.
-     * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
      * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
      * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
-    constructor(key, val, count = 1) {
-        super(key, val);
+    constructor(key, value, count = 1) {
+        super(key, value);
         this.count = count;
     }
 }
@@ -41,13 +41,13 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+     * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
-    createNode(key, val, count) {
-        return new TreeMultisetNode(key, val, count);
+    createNode(key, value, count) {
+        return new TreeMultisetNode(key, value, count);
     }
     /**
      * The `add` function adds a new node to a binary search tree, updating the count if the key already
@@ -55,23 +55,23 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
      * `BTNKey` (which represents the key of the node to be added), a `N` (which represents a
      * node to be added), or `null` (which represents a null node).
-     * @param [val] - The `val` parameter represents the value associated with the key that is being
+     * @param [value] - The `value` parameter represents the value associated with the key that is being
      * added to the binary tree.
      * @param [count=1] - The `count` parameter represents the number of occurrences of the key/value
      * pair that will be added to the binary tree. It has a default value of 1, which means that if no
      * count is specified, the default count will be 1.
      * @returns The function `add` returns a value of type `N | null | undefined`.
      */
-    add(keyOrNode, val, count = 1) {
+    add(keyOrNode, value, count = 1) {
         let inserted = undefined, newNode;
         if (keyOrNode instanceof TreeMultisetNode) {
-            newNode = this.createNode(keyOrNode.key, keyOrNode.val, keyOrNode.count);
+            newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
         }
         else if (keyOrNode === null) {
             newNode = null;
         }
         else {
-            newNode = this.createNode(keyOrNode, val, count);
+            newNode = this.createNode(keyOrNode, value, count);
         }
         if (!this.root) {
             this._setRoot(newNode);
@@ -86,7 +86,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                 if (cur) {
                     if (newNode) {
                         if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
-                            cur.val = newNode.val;
+                            cur.value = newNode.value;
                             cur.count += newNode.count;
                             this._setCount(this.count + newNode.count);
                             traversing = false;
@@ -187,7 +187,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         for (let i = 0; i < keysOrNodes.length; i++) {
             const keyOrNode = keysOrNodes[i];
             if (keyOrNode instanceof TreeMultisetNode) {
-                inserted.push(this.add(keyOrNode.key, keyOrNode.val, keyOrNode.count));
+                inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
                 continue;
             }
             if (keyOrNode === null) {
@@ -217,7 +217,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.key, midNode.val, midNode.count);
+                this.add(midNode.key, midNode.value, midNode.count);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -233,7 +233,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.key, midNode.val, midNode.count);
+                        this.add(midNode.key, midNode.value, midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -329,16 +329,16 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      */
     _swap(srcNode, destNode) {
-        const { key, val, count, height } = destNode;
-        const tempNode = this.createNode(key, val, count);
+        const { key, value, count, height } = destNode;
+        const tempNode = this.createNode(key, value, count);
         if (tempNode) {
             tempNode.height = height;
             destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
+            destNode.value = srcNode.value;
             destNode.count = srcNode.count;
             destNode.height = srcNode.height;
             srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
+            srcNode.value = tempNode.value;
             srcNode.count = tempNode.count;
             srcNode.height = tempNode.height;
         }

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

@@ -5,31 +5,31 @@ export declare abstract class AbstractVertex<V = any> {
      * 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
      * used to uniquely identify the vertex object.
-     * @param {V} [val] - The parameter "val" is an optional parameter of type V. It is used to assign a value to the
+     * @param {V} [value] - The parameter "value" is an optional parameter of type V. It is used to assign a value to the
      * vertex. If no value is provided, it will be set to undefined.
      */
-    protected constructor(key: VertexKey, val?: V);
+    protected constructor(key: VertexKey, value?: V);
     private _key;
     get key(): VertexKey;
     set key(v: VertexKey);
-    private _val;
-    get val(): V | undefined;
-    set val(value: V | undefined);
+    private _value;
+    get value(): V | undefined;
+    set value(value: V | undefined);
 }
-export declare abstract class AbstractEdge<VO = any> {
+export declare abstract class AbstractEdge<E = any> {
     /**
      * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
      * object.
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the object. If
      * a value is provided, it will be assigned to the `_weight` property. If no value is provided, the default value of 1
      * will be assigned.
-     * @param {VO} [val] - The `val` parameter is of type `VO`, which means it can be any type. It is an optional parameter,
+     * @param {VO} [value] - The `value` parameter is of type `VO`, which means it can be any type. It is an optional parameter,
      * meaning it can be omitted when creating an instance of the class.
      */
-    protected constructor(weight?: number, val?: VO);
-    private _val;
-    get val(): VO | undefined;
-    set val(value: VO | undefined);
+    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);
@@ -53,18 +53,18 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * 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.
      * @param key
-     * @param val
+     * @param value
      */
-    abstract createVertex(key: VertexKey, val?: V): VO;
+    abstract createVertex(key: VertexKey, value?: V): 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.
      * 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.
      * @param srcOrV1
      * @param destOrV2
      * @param weight
-     * @param val
+     * @param value
      */
-    abstract createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): EO;
+    abstract createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
     abstract deleteEdge(edge: EO): EO | null;
     abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null;
     abstract degreeOf(vertexOrKey: VO | VertexKey): number;
@@ -88,7 +88,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      */
     hasVertex(vertexOrKey: VO | VertexKey): boolean;
     addVertex(vertex: VO): boolean;
-    addVertex(key: VertexKey, val?: V): boolean;
+    addVertex(key: VertexKey, value?: V): boolean;
     /**
      * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
      * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
@@ -114,7 +114,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      */
     hasEdge(v1: VertexKey | VO, v2: VertexKey | VO): boolean;
     addEdge(edge: EO): boolean;
-    addEdge(src: VO | VertexKey, dest: VO | VertexKey, weight?: number, val?: E): boolean;
+    addEdge(src: VO | VertexKey, dest: VO | VertexKey, weight?: number, value?: E): boolean;
     /**
      * The function sets the weight of an edge between two vertices in a graph.
      * @param {VertexKey | VO} srcOrKey - The `srcOrKey` parameter can be either a `VertexKey` or a `VO` object. It represents

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

@@ -16,12 +16,12 @@ class AbstractVertex {
      * 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
      * used to uniquely identify the vertex object.
-     * @param {V} [val] - The parameter "val" is an optional parameter of type V. It is used to assign a value to the
+     * @param {V} [value] - The parameter "value" is an optional parameter of type V. It is used to assign a value to the
      * vertex. If no value is provided, it will be set to undefined.
      */
-    constructor(key, val) {
+    constructor(key, value) {
         this._key = key;
-        this._val = val;
+        this._value = value;
     }
     get key() {
         return this._key;
@@ -29,11 +29,11 @@ class AbstractVertex {
     set key(v) {
         this._key = v;
     }
-    get val() {
-        return this._val;
+    get value() {
+        return this._value;
     }
-    set val(value) {
-        this._val = value;
+    set value(value) {
+        this._value = value;
     }
 }
 exports.AbstractVertex = AbstractVertex;
@@ -44,19 +44,19 @@ class AbstractEdge {
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the object. If
      * a value is provided, it will be assigned to the `_weight` property. If no value is provided, the default value of 1
      * will be assigned.
-     * @param {VO} [val] - The `val` parameter is of type `VO`, which means it can be any type. It is an optional parameter,
+     * @param {VO} [value] - The `value` parameter is of type `VO`, which means it can be any type. It is an optional parameter,
      * meaning it can be omitted when creating an instance of the class.
      */
-    constructor(weight, val) {
+    constructor(weight, value) {
         this._weight = weight !== undefined ? weight : 1;
-        this._val = val;
+        this._value = value;
         this._hashCode = (0, utils_1.uuidV4)();
     }
-    get val() {
-        return this._val;
+    get value() {
+        return this._value;
     }
-    set val(value) {
-        this._val = value;
+    set value(value) {
+        this._value = value;
     }
     get weight() {
         return this._weight;
@@ -107,12 +107,12 @@ class AbstractGraph {
     hasVertex(vertexOrKey) {
         return this._vertices.has(this._getVertexKey(vertexOrKey));
     }
-    addVertex(keyOrVertex, val) {
+    addVertex(keyOrVertex, value) {
         if (keyOrVertex instanceof AbstractVertex) {
             return this._addVertexOnly(keyOrVertex);
         }
         else {
-            const newVertex = this.createVertex(keyOrVertex, val);
+            const newVertex = this.createVertex(keyOrVertex, value);
             return this._addVertexOnly(newVertex);
         }
     }
@@ -152,7 +152,7 @@ class AbstractGraph {
         const edge = this.getEdge(v1, v2);
         return !!edge;
     }
-    addEdge(srcOrEdge, dest, weight, val) {
+    addEdge(srcOrEdge, dest, weight, value) {
         if (srcOrEdge instanceof AbstractEdge) {
             return this._addEdgeOnly(srcOrEdge);
         }
@@ -164,7 +164,7 @@ class AbstractGraph {
                     srcOrEdge = srcOrEdge.key;
                 if (dest instanceof AbstractVertex)
                     dest = dest.key;
-                const newEdge = this.createEdge(srcOrEdge, dest, weight, val);
+                const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
                 return this._addEdgeOnly(newEdge);
             }
             else {
@@ -406,10 +406,10 @@ class AbstractGraph {
         const getMinOfNoSeen = () => {
             let min = Infinity;
             let minV = null;
-            for (const [key, val] of distMap) {
+            for (const [key, value] of distMap) {
                 if (!seen.has(key)) {
-                    if (val < min) {
-                        min = val;
+                    if (value < min) {
+                        min = value;
                         minV = key;
                     }
                 }
@@ -530,7 +530,7 @@ class AbstractGraph {
                 distMap.set(vertexOrKey, Infinity);
         }
         const heap = new priority_queue_1.PriorityQueue({ comparator: (a, b) => a.key - b.key });
-        heap.add({ key: 0, val: srcVertex });
+        heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
         /**
@@ -558,7 +558,7 @@ class AbstractGraph {
         while (heap.size > 0) {
             const curHeapNode = heap.poll();
             const dist = curHeapNode === null || curHeapNode === void 0 ? void 0 : curHeapNode.key;
-            const cur = curHeapNode === null || curHeapNode === void 0 ? void 0 : curHeapNode.val;
+            const cur = curHeapNode === null || curHeapNode === void 0 ? void 0 : curHeapNode.value;
             if (dist !== undefined) {
                 if (cur) {
                     seen.add(cur);
@@ -579,7 +579,7 @@ class AbstractGraph {
                                 const distSrcToNeighbor = distMap.get(neighbor);
                                 if (distSrcToNeighbor) {
                                     if (dist + weight < distSrcToNeighbor) {
-                                        heap.add({ key: dist + weight, val: neighbor });
+                                        heap.add({ key: dist + weight, value: neighbor });
                                         preMap.set(neighbor, cur);
                                         distMap.set(neighbor, dist + weight);
                                     }

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

@@ -6,10 +6,10 @@ export declare class DirectedVertex<V = any> extends AbstractVertex<V> {
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or data structure.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(key: VertexKey, val?: V);
+    constructor(key: VertexKey, value?: V);
 }
 export declare class DirectedEdge<E = any> extends AbstractEdge<E> {
     /**
@@ -20,10 +20,10 @@ export declare class DirectedEdge<E = any> extends AbstractEdge<E> {
      * @param {VertexKey} dest - The `dest` parameter represents the destination vertex of an edge. It is of type
      * `VertexKey`, which is likely a unique identifier for a vertex in a graph.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {E} [val] - The `val` parameter is an optional parameter of type `E`. It represents the value associated with
+     * @param {E} [value] - The `value` parameter is an optional parameter of type `E`. It represents the value associated with
      * the edge.
      */
-    constructor(src: VertexKey, dest: VertexKey, weight?: number, val?: E);
+    constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E);
     private _src;
     get src(): VertexKey;
     set src(v: VertexKey);
@@ -48,12 +48,12 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * The function creates a new vertex with an optional value and returns it.
      * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is of type `VertexKey`, which
      * could be a number or a string depending on how you want to identify your vertices.
-     * @param [val] - The 'val' parameter is an optional value that can be assigned to the vertex. If a value is provided,
-     * it will be assigned to the 'val' property of the vertex. If no value is provided, the 'val' property will be
+     * @param [value] - The 'value' parameter is an optional value that can be assigned to the vertex. If a value is provided,
+     * it will be assigned to the 'value' property of the vertex. If no value is provided, the 'value' property will be
      * assigned the same value as the 'key' parameter
      * @returns a new instance of a DirectedVertex object, casted as type VO.
      */
-    createVertex(key: VertexKey, val?: V): VO;
+    createVertex(key: VertexKey, value?: V): 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.
      * 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.
@@ -64,20 +64,20 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for the edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge. If no
      * weight is provided, it defaults to 1.
-     * @param [val] - The 'val' parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * @param [value] - The 'value' parameter is an optional value that can be assigned to the edge. It can be of any type and
      * is used to store additional information or data associated with the edge.
      * @returns a new instance of a DirectedEdge object, casted as type EO.
      */
-    createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E): EO;
+    createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO;
     /**
      * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-     * @param {VO | null | VertexKey} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-     * @param {VO | null | VertexKey} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+     * @param {VO | VertexKey | null} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+     * @param {VO | VertexKey | null} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
      * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `null` if the
      * destination is not specified.
      * @returns the first edge found between the source and destination vertices, or null if no such edge is found.
      */
-    getEdge(srcOrKey: VO | null | VertexKey, destOrKey: VO | null | VertexKey): EO | null;
+    getEdge(srcOrKey: VO | VertexKey | null, destOrKey: VO | VertexKey | null): EO | null;
     /**
      * The function removes an edge between two vertices in a graph and returns the removed edge.
      * @param {VO | VertexKey} srcOrKey - The source vertex or its ID.

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

@@ -15,11 +15,11 @@ class DirectedVertex extends abstract_graph_1.AbstractVertex {
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or data structure.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(key, val) {
-        super(key, val);
+    constructor(key, value) {
+        super(key, value);
     }
 }
 exports.DirectedVertex = DirectedVertex;
@@ -32,11 +32,11 @@ class DirectedEdge extends abstract_graph_1.AbstractEdge {
      * @param {VertexKey} dest - The `dest` parameter represents the destination vertex of an edge. It is of type
      * `VertexKey`, which is likely a unique identifier for a vertex in a graph.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {E} [val] - The `val` parameter is an optional parameter of type `E`. It represents the value associated with
+     * @param {E} [value] - The `value` parameter is an optional parameter of type `E`. It represents the value associated with
      * the edge.
      */
-    constructor(src, dest, weight, val) {
-        super(weight, val);
+    constructor(src, dest, weight, value) {
+        super(weight, value);
         this._src = src;
         this._dest = dest;
     }
@@ -77,13 +77,13 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
      * The function creates a new vertex with an optional value and returns it.
      * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is of type `VertexKey`, which
      * could be a number or a string depending on how you want to identify your vertices.
-     * @param [val] - The 'val' parameter is an optional value that can be assigned to the vertex. If a value is provided,
-     * it will be assigned to the 'val' property of the vertex. If no value is provided, the 'val' property will be
+     * @param [value] - The 'value' parameter is an optional value that can be assigned to the vertex. If a value is provided,
+     * it will be assigned to the 'value' property of the vertex. If no value is provided, the 'value' property will be
      * assigned the same value as the 'key' parameter
      * @returns a new instance of a DirectedVertex object, casted as type VO.
      */
-    createVertex(key, val) {
-        return new DirectedVertex(key, val !== null && val !== void 0 ? val : key);
+    createVertex(key, value) {
+        return new DirectedVertex(key, value !== null && value !== void 0 ? value : key);
     }
     /**
      * 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.
@@ -95,17 +95,17 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
      * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for the edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge. If no
      * weight is provided, it defaults to 1.
-     * @param [val] - The 'val' parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * @param [value] - The 'value' parameter is an optional value that can be assigned to the edge. It can be of any type and
      * is used to store additional information or data associated with the edge.
      * @returns a new instance of a DirectedEdge object, casted as type EO.
      */
-    createEdge(src, dest, weight, val) {
-        return new DirectedEdge(src, dest, weight !== null && weight !== void 0 ? weight : 1, val);
+    createEdge(src, dest, weight, value) {
+        return new DirectedEdge(src, dest, weight !== null && weight !== void 0 ? weight : 1, value);
     }
     /**
      * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-     * @param {VO | null | VertexKey} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-     * @param {VO | null | VertexKey} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+     * @param {VO | VertexKey | null} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+     * @param {VO | VertexKey | null} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
      * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `null` if the
      * destination is not specified.
      * @returns the first edge found between the source and destination vertices, or null if no such edge is found.

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

@@ -10,10 +10,10 @@ export declare class MapVertex<V = any> extends DirectedVertex<V> {
      * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
      * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
      * values ranging from -180 to 180.
-     * @param {V} [val] - The "val" parameter is an optional value of type V. It is not required to be provided when
+     * @param {V} [value] - The "value" parameter is an optional value of type V. It is not required to be provided when
      * creating an instance of the class.
      */
-    constructor(key: VertexKey, val: V, lat: number, long: number);
+    constructor(key: VertexKey, value: V, lat: number, long: number);
     private _lat;
     get lat(): number;
     set lat(value: number);
@@ -29,10 +29,10 @@ export declare class MapEdge<E = any> extends DirectedEdge<E> {
      * a graph.
      * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {E} [val] - The "val" parameter is an optional parameter of type E. It is used to store additional
+     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store additional
      * information or data associated with the edge.
      */
-    constructor(src: VertexKey, dest: VertexKey, weight?: number, val?: E);
+    constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E);
 }
 export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVertex<V>, EO extends MapEdge<E> = MapEdge<E>> extends DirectedGraph<V, E, VO, EO> {
     /**
@@ -55,14 +55,14 @@ export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVer
      * 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
      * be a string or a number depending on how you define it in your code.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the vertex. It
-     * is of type `V`, which means it should be of the same type as the `val` property of the vertex class `VO`.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the `value` property of the vertex. It
+     * is of type `V`, which means it should be of the same type as the `value` property of the vertex class `VO`.
      * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
      * position of the vertex on the Earth's surface in the north-south direction.
      * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
      * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
      */
-    createVertex(key: VertexKey, val?: V, lat?: number, long?: number): VO;
+    createVertex(key: VertexKey, value?: V, lat?: number, long?: number): VO;
     /**
      * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
      * @param {VertexKey} src - The source vertex ID of the edge. It represents the starting point of the edge.
@@ -71,9 +71,9 @@ export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVer
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. It
      * is used to assign a numerical value to the edge, which can be used in algorithms such as shortest path algorithms.
      * If the weight is not provided, it can be set to a default value or left undefined.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type,
      * depending on the specific implementation of the `MapEdge` class.
      * @returns a new instance of the `MapEdge` class, cast as type `EO`.
      */
-    createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E): EO;
+    createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO;
 }

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

@@ -12,11 +12,11 @@ class MapVertex extends directed_graph_1.DirectedVertex {
      * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
      * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
      * values ranging from -180 to 180.
-     * @param {V} [val] - The "val" parameter is an optional value of type V. It is not required to be provided when
+     * @param {V} [value] - The "value" parameter is an optional value of type V. It is not required to be provided when
      * creating an instance of the class.
      */
-    constructor(key, val, lat, long) {
-        super(key, val);
+    constructor(key, value, lat, long) {
+        super(key, value);
         this._lat = lat;
         this._long = long;
     }
@@ -42,11 +42,11 @@ class MapEdge extends directed_graph_1.DirectedEdge {
      * a graph.
      * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {E} [val] - The "val" parameter is an optional parameter of type E. It is used to store additional
+     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store additional
      * information or data associated with the edge.
      */
-    constructor(src, dest, weight, val) {
-        super(src, dest, weight, val);
+    constructor(src, dest, weight, value) {
+        super(src, dest, weight, value);
     }
 }
 exports.MapEdge = MapEdge;
@@ -82,15 +82,15 @@ class MapGraph extends directed_graph_1.DirectedGraph {
      * 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
      * be a string or a number depending on how you define it in your code.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the vertex. It
-     * is of type `V`, which means it should be of the same type as the `val` property of the vertex class `VO`.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the `value` property of the vertex. It
+     * is of type `V`, which means it should be of the same type as the `value` property of the vertex class `VO`.
      * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
      * position of the vertex on the Earth's surface in the north-south direction.
      * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
      * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
      */
-    createVertex(key, val, lat = this.origin[0], long = this.origin[1]) {
-        return new MapVertex(key, val, lat, long);
+    createVertex(key, value, lat = this.origin[0], long = this.origin[1]) {
+        return new MapVertex(key, value, lat, long);
     }
     /**
      * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
@@ -100,12 +100,12 @@ class MapGraph extends directed_graph_1.DirectedGraph {
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. It
      * is used to assign a numerical value to the edge, which can be used in algorithms such as shortest path algorithms.
      * If the weight is not provided, it can be set to a default value or left undefined.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type,
      * depending on the specific implementation of the `MapEdge` class.
      * @returns a new instance of the `MapEdge` class, cast as type `EO`.
      */
-    createEdge(src, dest, weight, val) {
-        return new MapEdge(src, dest, weight, val);
+    createEdge(src, dest, weight, value) {
+        return new MapEdge(src, dest, weight, value);
     }
 }
 exports.MapGraph = MapGraph;