data-structure-typed 1.50.2 → 1.50.4

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

@@ -13,7 +13,7 @@ export class UndirectedVertex extends AbstractVertex {
     }
 }
 export class UndirectedEdge extends AbstractEdge {
-    vertexMap;
+    endpoints;
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -26,7 +26,7 @@ export class UndirectedEdge extends AbstractEdge {
      */
     constructor(v1, v2, weight, value) {
         super(weight, value);
-        this.vertexMap = [v1, v2];
+        this.endpoints = [v1, v2];
     }
 }
 export class UndirectedGraph extends AbstractGraph {
@@ -77,7 +77,7 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `getEdge` returns the first edge that connects two vertexMap, or undefined if no such edge exists.
+     * The function `getEdge` returns the first edge that connects two endpoints, or undefined if no such edge exists.
      * @param {VO | VertexKey | undefined} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `undefined`, or `VertexKey` (a string or number representing the ID of a vertex).
      * @param {VO | VertexKey | undefined} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
@@ -90,7 +90,7 @@ export class UndirectedGraph extends AbstractGraph {
             const vertex1 = this._getVertex(v1);
             const vertex2 = this._getVertex(v2);
             if (vertex1 && vertex2) {
-                edgeMap = this._edgeMap.get(vertex1)?.filter(e => e.vertexMap.includes(vertex2.key));
+                edgeMap = this._edgeMap.get(vertex1)?.filter(e => e.endpoints.includes(vertex2.key));
             }
         }
         return edgeMap ? edgeMap[0] || undefined : undefined;
@@ -107,7 +107,7 @@ export class UndirectedGraph extends AbstractGraph {
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (EO) if it exists, or undefined if either of the vertexMap (VO) does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either of the endpoints (VO) does not exist.
      */
     deleteEdgeBetween(v1, v2) {
         const vertex1 = this._getVertex(v1);
@@ -118,11 +118,11 @@ export class UndirectedGraph extends AbstractGraph {
         const v1Edges = this._edgeMap.get(vertex1);
         let removed = undefined;
         if (v1Edges) {
-            removed = arrayRemove(v1Edges, (e) => e.vertexMap.includes(vertex2.key))[0] || undefined;
+            removed = arrayRemove(v1Edges, (e) => e.endpoints.includes(vertex2.key))[0] || undefined;
         }
         const v2Edges = this._edgeMap.get(vertex2);
         if (v2Edges) {
-            arrayRemove(v2Edges, (e) => e.vertexMap.includes(vertex1.key));
+            arrayRemove(v2Edges, (e) => e.endpoints.includes(vertex1.key));
         }
         return removed;
     }
@@ -134,7 +134,7 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `deleteEdge` deletes an edge between two vertexMap in a graph.
+     * The function `deleteEdge` deletes an edge between two endpoints in a graph.
      * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
      * either an edge object or a vertex key.
      * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
@@ -155,8 +155,8 @@ export class UndirectedGraph extends AbstractGraph {
             }
         }
         else {
-            oneSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[0]);
-            otherSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[1]);
+            oneSide = this._getVertex(edgeOrOneSideVertexKey.endpoints[0]);
+            otherSide = this._getVertex(edgeOrOneSideVertexKey.endpoints[1]);
         }
         if (oneSide && otherSide) {
             return this.deleteEdgeBetween(oneSide, otherSide);
@@ -195,7 +195,7 @@ export class UndirectedGraph extends AbstractGraph {
                 const neighborEdges = this._edgeMap.get(neighbor);
                 if (neighborEdges) {
                     const restEdges = neighborEdges.filter(edge => {
-                        return !edge.vertexMap.includes(vertexKey);
+                        return !edge.endpoints.includes(vertexKey);
                     });
                     this._edgeMap.set(neighbor, restEdges);
                 }
@@ -277,7 +277,7 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
      * Space Complexity: O(|E|)
      *
-     * The function "getNeighbors" returns an array of neighboring vertexMap for a given vertex or vertex ID.
+     * The function "getNeighbors" returns an array of neighboring endpoints for a given vertex or vertex ID.
      * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
      * @returns an array of vertexMap (VO[]).
@@ -288,7 +288,7 @@ export class UndirectedGraph extends AbstractGraph {
         if (vertex) {
             const neighborEdges = this.edgesOf(vertex);
             for (const edge of neighborEdges) {
-                const neighbor = this._getVertex(edge.vertexMap.filter(e => e !== vertex.key)[0]);
+                const neighbor = this._getVertex(edge.endpoints.filter(e => e !== vertex.key)[0]);
                 if (neighbor) {
                     neighbors.push(neighbor);
                 }
@@ -304,18 +304,18 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEndsOfEdge" returns the vertexMap at the ends of an edge if the edge exists in the graph, otherwise
+     * The function "getEndsOfEdge" returns the endpoints at the ends of an edge if the edge exists in the graph, otherwise
      * it returns undefined.
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertexMap `[VO, VO]` if the edge exists in the
+     * @returns The function `getEndsOfEdge` returns an array containing two endpoints `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge) {
-        if (!this.hasEdge(edge.vertexMap[0], edge.vertexMap[1])) {
+        if (!this.hasEdge(edge.endpoints[0], edge.endpoints[1])) {
             return undefined;
         }
-        const v1 = this._getVertex(edge.vertexMap[0]);
-        const v2 = this._getVertex(edge.vertexMap[1]);
+        const v1 = this._getVertex(edge.endpoints[0]);
+        const v2 = this._getVertex(edge.endpoints[1]);
         if (v1 && v2) {
             return [v1, v2];
         }
@@ -330,6 +330,20 @@ export class UndirectedGraph extends AbstractGraph {
     isEmpty() {
         return this.vertexMap.size === 0 && this.edgeMap.size === 0;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the vertex and edge maps to empty maps.
+     */
+    clear() {
+        this._vertexMap = new Map();
+        this._edgeMap = new Map();
+    }
     /**
      * The clone function creates a new UndirectedGraph object and copies the
      * vertexMap and edgeMap from this graph to the new one. This is done by
@@ -349,6 +363,100 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *   Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     *
+     * The function `tarjan` implements the Tarjan's algorithm to find bridges and cut vertices in a
+     * graph.
+     * @returns The function `tarjan()` returns an object with the following properties:
+     */
+    tarjan() {
+        const dfnMap = new Map();
+        const lowMap = new Map();
+        const bridges = [];
+        const cutVertices = [];
+        let time = 0;
+        const dfs = (vertex, parent) => {
+            dfnMap.set(vertex, time);
+            lowMap.set(vertex, time);
+            time++;
+            const neighbors = this.getNeighbors(vertex);
+            let childCount = 0;
+            for (const neighbor of neighbors) {
+                if (!dfnMap.has(neighbor)) {
+                    childCount++;
+                    dfs(neighbor, vertex);
+                    lowMap.set(vertex, Math.min(lowMap.get(vertex), lowMap.get(neighbor)));
+                    if (lowMap.get(neighbor) > dfnMap.get(vertex)) {
+                        // Found a bridge
+                        const edge = this.getEdge(vertex, neighbor);
+                        if (edge) {
+                            bridges.push(edge);
+                        }
+                    }
+                    if (parent !== undefined && lowMap.get(neighbor) >= dfnMap.get(vertex)) {
+                        // Found an articulation point
+                        cutVertices.push(vertex);
+                    }
+                }
+                else if (neighbor !== parent) {
+                    lowMap.set(vertex, Math.min(lowMap.get(vertex), dfnMap.get(neighbor)));
+                }
+            }
+            if (parent === undefined && childCount > 1) {
+                // Special case for root in DFS tree
+                cutVertices.push(vertex);
+            }
+        };
+        for (const vertex of this.vertexMap.values()) {
+            if (!dfnMap.has(vertex)) {
+                dfs(vertex, undefined);
+            }
+        }
+        return {
+            dfnMap,
+            lowMap,
+            bridges,
+            cutVertices
+        };
+    }
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     */
+    /**
+     * The function "getBridges" returns an array of bridges in a graph using the Tarjan's algorithm.
+     * @returns The function `getBridges()` is returning the bridges found using the Tarjan's algorithm.
+     */
+    getBridges() {
+        return this.tarjan().bridges;
+    }
+    /**
+     * The function "getCutVertices" returns an array of cut vertices using the Tarjan's algorithm.
+     * @returns the cut vertices found using the Tarjan's algorithm.
+     */
+    getCutVertices() {
+        return this.tarjan().cutVertices;
+    }
+    /**
+     * The function returns the dfnMap property of the result of the tarjan() function.
+     * @returns the `dfnMap` property of the result of calling the `tarjan()` function.
+     */
+    getDFNMap() {
+        return this.tarjan().dfnMap;
+    }
+    /**
+     * The function returns the lowMap property of the result of the tarjan() function.
+     * @returns the lowMap property of the result of calling the tarjan() function.
+     */
+    getLowMap() {
+        return this.tarjan().lowMap;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -358,7 +466,7 @@ export class UndirectedGraph extends AbstractGraph {
      * @returns a boolean value.
      */
     _addEdge(edge) {
-        for (const end of edge.vertexMap) {
+        for (const end of edge.endpoints) {
             const endVertex = this._getVertex(end);
             if (endVertex === undefined)
                 return false;

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

@@ -14,10 +14,6 @@ import { IterableEntryBase } from '../base';
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
-    protected _store: {
-        [key: string]: HashMapStoreItem<K, V>;
-    };
-    protected _objMap: Map<object, V>;
     /**
      * The constructor function initializes a HashMap object with an optional initial collection and
      * options.
@@ -26,25 +22,44 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
     constructor(rawCollection?: Iterable<R | [K, V]>, options?: HashMapOptions<K, V, R>);
+    protected _store: {
+        [key: string]: HashMapStoreItem<K, V>;
+    };
+    /**
+     * The function returns the store object, which is a dictionary of HashMapStoreItem objects.
+     * @returns The store property is being returned. It is a dictionary-like object with string keys and
+     * values of type HashMapStoreItem<K, V>.
+     */
+    get store(): {
+        [p: string]: HashMapStoreItem<K, V>;
+    };
+    protected _objMap: Map<object, V>;
+    /**
+     * The function returns the object map.
+     * @returns The `objMap` property is being returned, which is a `Map` object with keys of type
+     * `object` and values of type `V`.
+     */
+    get objMap(): Map<object, V>;
     protected _toEntryFn: (rawElement: R) => [K, V];
     /**
      * The function returns the value of the _toEntryFn property.
      * @returns The function being returned is `this._toEntryFn`.
      */
     get toEntryFn(): (rawElement: R) => [K, V];
-    /**
-     * The hasFn function is a function that takes in an item and returns a boolean
-     * indicating whether the item is contained within the hash table.
-     *
-     * @return The hash function
-     */
-    get hasFn(): (key: K) => string;
     protected _size: number;
     /**
      * The function returns the size of an object.
      * @returns The size of the object, which is a number.
      */
     get size(): number;
+    protected _hashFn: (key: K) => string;
+    /**
+     * The hasFn function is a function that takes in an item and returns a boolean
+     * indicating whether the item is contained within the hash table.
+     *
+     * @return The hash function
+     */
+    get hashFn(): (key: K) => string;
     /**
      * The function checks if a given element is an array with exactly two elements.
      * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
@@ -104,6 +119,10 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * successfully deleted from the map, and `false` if the key was not found in the map.
      */
     delete(key: K): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     /**
      * The clone function creates a new HashMap with the same key-value pairs as
      * this one. The clone function is useful for creating a copy of an existing
@@ -131,10 +150,6 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * the provided callback function.
      */
     map<U>(callbackfn: EntryCallback<K, V, U>, thisArg?: any): HashMap<K, U>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -166,8 +181,19 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * object map.
      */
     protected _getIterator(): IterableIterator<[K, V]>;
-    protected _hashFn: (key: K) => string;
+    /**
+     * The function checks if a given key is an object or a function.
+     * @param {any} key - The parameter "key" can be of any type.
+     * @returns a boolean value.
+     */
     protected _isObjKey(key: any): key is object | ((...args: any[]) => any);
+    /**
+     * The function `_getNoObjKey` takes a key and returns a string representation of the key, handling
+     * different types of keys.
+     * @param {K} key - The `key` parameter is of type `K`, which represents the type of the key being
+     * passed to the `_getNoObjKey` function.
+     * @returns a string value.
+     */
     protected _getNoObjKey(key: K): string;
 }
 /**
@@ -176,10 +202,6 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
  * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
  */
 export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
-    protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
-    protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
-    protected _head: HashMapLinkedNode<K, V | undefined>;
-    protected _tail: HashMapLinkedNode<K, V | undefined>;
     protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
     /**
      * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
@@ -191,6 +213,45 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * properties:
      */
     constructor(rawCollection?: Iterable<R>, options?: LinkedHashMapOptions<K, V, R>);
+    protected _hashFn: (key: K) => string;
+    /**
+     * The function returns the hash function used for generating a hash value for a given key.
+     * @returns The hash function that takes a key of type K and returns a string.
+     */
+    get hashFn(): (key: K) => string;
+    protected _objHashFn: (key: K) => object;
+    /**
+     * The function returns the object hash function.
+     * @returns The function `objHashFn` is being returned.
+     */
+    get objHashFn(): (key: K) => object;
+    protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
+    /**
+     * The function returns a record of HashMapLinkedNode objects with string keys.
+     * @returns The method is returning a Record object, which is a TypeScript type that represents an
+     * object with string keys and values that are HashMapLinkedNode objects with keys of type K and
+     * values of type V or undefined.
+     */
+    get noObjMap(): Record<string, HashMapLinkedNode<K, V | undefined>>;
+    protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
+    /**
+     * The function returns the WeakMap object used to map objects to HashMapLinkedNode instances.
+     * @returns The `objMap` property is being returned.
+     */
+    get objMap(): WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
+    protected _head: HashMapLinkedNode<K, V | undefined>;
+    /**
+     * The function returns the head node of a HashMapLinkedNode.
+     * @returns The method `getHead()` is returning a `HashMapLinkedNode` object with key type `K` and
+     * value type `V | undefined`.
+     */
+    get head(): HashMapLinkedNode<K, V | undefined>;
+    protected _tail: HashMapLinkedNode<K, V | undefined>;
+    /**
+     * The function returns the tail node of a HashMapLinkedNode.
+     * @returns The `_tail` property of type `HashMapLinkedNode<K, V | undefined>` is being returned.
+     */
+    get tail(): HashMapLinkedNode<K, V | undefined>;
     protected _toEntryFn: (rawElement: R) => [K, V];
     /**
      * The function returns the value of the _toEntryFn property.
@@ -203,6 +264,10 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @returns The size of the object.
      */
     get size(): number;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -212,6 +277,10 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * value (V).
      */
     get first(): [K, V] | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -230,6 +299,10 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * key and value.
      */
     reverseBegin(): Generator<(K | V | undefined)[], void, unknown>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -259,6 +332,10 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @returns The method `has` is returning a boolean value.
      */
     has(key: K): boolean;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -274,7 +351,12 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     get(key: K): V | undefined;
     /**
-     * Time Complexity: O(n), where n is the index.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The function `at` retrieves the key-value pair at a specified index in a linked list.
@@ -286,6 +368,11 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     at(index: number): V | undefined;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -297,6 +384,11 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     delete(key: K): boolean;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -307,6 +399,11 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     deleteAt(index: number): boolean;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -323,6 +420,11 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     isEntry(rawElement: any): rawElement is [K, V];
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -344,6 +446,11 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     clone(): LinkedHashMap<K, V>;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -360,6 +467,11 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V>;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -393,9 +505,13 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @returns The method is returning a boolean value.
      */
     put(key: K, value: V): boolean;
-    protected _hashFn: (key: K) => string;
-    protected _objHashFn: (key: K) => object;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * where n is the number of entries in the LinkedHashMap.
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      * where n is the number of entries in the LinkedHashMap.
@@ -403,6 +519,10 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
     protected _getIterator(): Generator<[K, V], void, unknown>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)