graph-typed 1.45.3 → 1.46.1

package/dist/data-structures/queue/deque.js

@@ -1,6 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayDeque = exports.ObjectDeque = exports.Deque = void 0;
 /**
  * data-structure-typed
  *
@@ -8,13 +6,534 @@ exports.ArrayDeque = exports.ObjectDeque = exports.Deque = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-const linked_list_1 = require("../linked-list");
-// O(n) time complexity of obtaining the value
-// O(1) time complexity of adding at the beginning and the end
-class Deque extends linked_list_1.DoublyLinkedList {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectDeque = exports.Deque = exports.DequeIterator = void 0;
+const utils_1 = require("../../utils");
+/**
+ * Deque can provide random access with O(1) time complexity
+ * Deque is usually more compact and efficient in memory usage because it does not require additional space to store pointers.
+ * Deque may experience performance jitter, but DoublyLinkedList will not
+ * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
+ */
+class DequeIterator {
+    constructor(index, deque, iterateDirection = 0 /* IterateDirection.DEFAULT */) {
+        this.index = index;
+        this.iterateDirection = iterateDirection;
+        if (this.iterateDirection === 0 /* IterateDirection.DEFAULT */) {
+            this.prev = function () {
+                if (this.index === 0) {
+                    (0, utils_1.throwRangeError)();
+                }
+                this.index -= 1;
+                return this;
+            };
+            this.next = function () {
+                if (this.index === this.deque.size) {
+                    (0, utils_1.throwRangeError)();
+                }
+                this.index += 1;
+                return this;
+            };
+        }
+        else {
+            this.prev = function () {
+                if (this.index === this.deque.size - 1) {
+                    (0, utils_1.throwRangeError)();
+                }
+                this.index += 1;
+                return this;
+            };
+            this.next = function () {
+                if (this.index === -1) {
+                    (0, utils_1.throwRangeError)();
+                }
+                this.index -= 1;
+                return this;
+            };
+        }
+        this.deque = deque;
+    }
+    get current() {
+        return this.deque.getAt(this.index);
+    }
+    set current(newElement) {
+        this.deque.setAt(this.index, newElement);
+    }
+    isAccessible() {
+        return this.index !== this.deque.size;
+    }
+    prev() {
+        return this;
+    }
+    next() {
+        return this;
+    }
+    clone() {
+        return new DequeIterator(this.index, this.deque, this.iterateDirection);
+    }
+}
+exports.DequeIterator = DequeIterator;
+class Deque {
+    constructor(elements = [], bucketSize = (1 << 12)) {
+        this._bucketFirst = 0;
+        this._firstInBucket = 0;
+        this._bucketLast = 0;
+        this._lastInBucket = 0;
+        this._bucketCount = 0;
+        this._buckets = [];
+        this._size = 0;
+        let _size;
+        if ('length' in elements) {
+            _size = elements.length;
+        }
+        else {
+            _size = elements.size;
+        }
+        this._bucketSize = bucketSize;
+        this._bucketCount = (0, utils_1.calcMinUnitsRequired)(_size, this._bucketSize) || 1;
+        for (let i = 0; i < this._bucketCount; ++i) {
+            this._buckets.push(new Array(this._bucketSize));
+        }
+        const needBucketNum = (0, utils_1.calcMinUnitsRequired)(_size, this._bucketSize);
+        this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
+        this._firstInBucket = this._lastInBucket = (this._bucketSize - _size % this._bucketSize) >> 1;
+        for (const element of elements) {
+            this.push(element);
+        }
+    }
+    get buckets() {
+        return this._buckets;
+    }
+    get size() {
+        return this._size;
+    }
+    get first() {
+        if (this.size === 0)
+            return;
+        return this._buckets[this._bucketFirst][this._firstInBucket];
+    }
+    get last() {
+        if (this.size === 0)
+            return;
+        return this._buckets[this._bucketLast][this._lastInBucket];
+    }
+    /**
+     * Time Complexity: Amortized O(1) - Generally constant time, but resizing when the deque is full leads to O(n).
+     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     */
+    empty() {
+        return this._size === 0;
+    }
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     */
+    isEmpty() {
+        return this.size === 0;
+    }
+    /**
+     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
+     * Space Complexity: O(n) - Due to potential resizing.
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     *
+     * The addLast function adds an element to the end of an array.
+     * @param {E} element - The element parameter represents the element that you want to add to the end of the
+     * data structure.
+     */
+    addLast(element) {
+        this.push(element);
+    }
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     */
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     *
+     * The function "popLast" removes and returns the last element of an array.
+     * @returns The last element of the array is being returned.
+     */
+    popLast() {
+        return this.pop();
+    }
+    /**
+     * Time Complexity: O(1).
+     * Space Complexity: O(n) - Due to potential resizing.
+     *
+     * The "addFirst" function adds an element to the beginning of an array.
+     * @param {E} element - The parameter "element" represents the element that you want to add to the
+     * beginning of the data structure.
+     */
+    addFirst(element) {
+        this.unshift(element);
+    }
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     *
+     * The function "popFirst" removes and returns the first element of an array.
+     * @returns The method `popFirst()` is returning the first element of the array after removing it
+     * from the beginning. If the array is empty, it will return `undefined`.
+     */
+    popFirst() {
+        return this.shift();
+    }
+    clear() {
+        this._buckets = [new Array(this._bucketSize)];
+        this._bucketCount = 1;
+        this._bucketFirst = this._bucketLast = this._size = 0;
+        this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+    }
+    begin() {
+        return new DequeIterator(0, this);
+    }
+    end() {
+        return new DequeIterator(this.size, this);
+    }
+    reverseBegin() {
+        return new DequeIterator(this.size - 1, this, 1 /* IterateDirection.REVERSE */);
+    }
+    reverseEnd() {
+        return new DequeIterator(-1, this, 1 /* IterateDirection.REVERSE */);
+    }
+    push(element) {
+        if (this.size) {
+            if (this._lastInBucket < this._bucketSize - 1) {
+                this._lastInBucket += 1;
+            }
+            else if (this._bucketLast < this._bucketCount - 1) {
+                this._bucketLast += 1;
+                this._lastInBucket = 0;
+            }
+            else {
+                this._bucketLast = 0;
+                this._lastInBucket = 0;
+            }
+            if (this._bucketLast === this._bucketFirst &&
+                this._lastInBucket === this._firstInBucket)
+                this._reallocate();
+        }
+        this._size += 1;
+        this._buckets[this._bucketLast][this._lastInBucket] = element;
+        return this.size;
+    }
+    pop() {
+        if (this.size === 0)
+            return;
+        const element = this._buckets[this._bucketLast][this._lastInBucket];
+        if (this.size !== 1) {
+            if (this._lastInBucket > 0) {
+                this._lastInBucket -= 1;
+            }
+            else if (this._bucketLast > 0) {
+                this._bucketLast -= 1;
+                this._lastInBucket = this._bucketSize - 1;
+            }
+            else {
+                this._bucketLast = this._bucketCount - 1;
+                this._lastInBucket = this._bucketSize - 1;
+            }
+        }
+        this._size -= 1;
+        return element;
+    }
+    unshift(element) {
+        if (this.size) {
+            if (this._firstInBucket > 0) {
+                this._firstInBucket -= 1;
+            }
+            else if (this._bucketFirst > 0) {
+                this._bucketFirst -= 1;
+                this._firstInBucket = this._bucketSize - 1;
+            }
+            else {
+                this._bucketFirst = this._bucketCount - 1;
+                this._firstInBucket = this._bucketSize - 1;
+            }
+            if (this._bucketFirst === this._bucketLast &&
+                this._firstInBucket === this._lastInBucket)
+                this._reallocate();
+        }
+        this._size += 1;
+        this._buckets[this._bucketFirst][this._firstInBucket] = element;
+        return this.size;
+    }
+    shift() {
+        if (this.size === 0)
+            return;
+        const element = this._buckets[this._bucketFirst][this._firstInBucket];
+        if (this.size !== 1) {
+            if (this._firstInBucket < this._bucketSize - 1) {
+                this._firstInBucket += 1;
+            }
+            else if (this._bucketFirst < this._bucketCount - 1) {
+                this._bucketFirst += 1;
+                this._firstInBucket = 0;
+            }
+            else {
+                this._bucketFirst = 0;
+                this._firstInBucket = 0;
+            }
+        }
+        this._size -= 1;
+        return element;
+    }
+    getAt(pos) {
+        utils_1.rangeCheck(pos, 0, this.size - 1);
+        const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+        return this._buckets[bucketIndex][indexInBucket];
+    }
+    setAt(pos, element) {
+        utils_1.rangeCheck(pos, 0, this.size - 1);
+        const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+        this._buckets[bucketIndex][indexInBucket] = element;
+    }
+    insertAt(pos, element, num = 1) {
+        const length = this.size;
+        utils_1.rangeCheck(pos, 0, length);
+        if (pos === 0) {
+            while (num--)
+                this.unshift(element);
+        }
+        else if (pos === this.size) {
+            while (num--)
+                this.push(element);
+        }
+        else {
+            const arr = [];
+            for (let i = pos; i < this.size; ++i) {
+                arr.push(this.getAt(i));
+            }
+            this.cut(pos - 1);
+            for (let i = 0; i < num; ++i)
+                this.push(element);
+            for (let i = 0; i < arr.length; ++i)
+                this.push(arr[i]);
+        }
+        return this.size;
+    }
+    cut(pos) {
+        if (pos < 0) {
+            this.clear();
+            return 0;
+        }
+        const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+        this._bucketLast = bucketIndex;
+        this._lastInBucket = indexInBucket;
+        this._size = pos + 1;
+        return this.size;
+    }
+    deleteAt(pos) {
+        utils_1.rangeCheck(pos, 0, this.size - 1);
+        if (pos === 0)
+            this.shift();
+        else if (pos === this.size - 1)
+            this.pop();
+        else {
+            const length = this.size - 1;
+            let { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(pos);
+            for (let i = pos; i < length; ++i) {
+                const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(pos + 1);
+                this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
+                curBucket = nextBucket;
+                curPointer = nextPointer;
+            }
+            this.pop();
+        }
+        return this.size;
+    }
+    delete(element) {
+        const size = this.size;
+        if (size === 0)
+            return 0;
+        let i = 0;
+        let index = 0;
+        while (i < size) {
+            const oldElement = this.getAt(i);
+            if (oldElement !== element) {
+                this.setAt(index, oldElement);
+                index += 1;
+            }
+            i += 1;
+        }
+        this.cut(index - 1);
+        return this.size;
+    }
+    deleteByIterator(iter) {
+        const index = iter.index;
+        this.deleteAt(index);
+        iter = iter.next();
+        return iter;
+    }
+    findIterator(element) {
+        for (let i = 0; i < this.size; ++i) {
+            if (this.getAt(i) === element) {
+                return new DequeIterator(i, this);
+            }
+        }
+        return this.end();
+    }
+    reverse() {
+        this._buckets.reverse().forEach(function (bucket) {
+            bucket.reverse();
+        });
+        const { _bucketFirst, _bucketLast, _firstInBucket, _lastInBucket } = this;
+        this._bucketFirst = this._bucketCount - _bucketLast - 1;
+        this._bucketLast = this._bucketCount - _bucketFirst - 1;
+        this._firstInBucket = this._bucketSize - _lastInBucket - 1;
+        this._lastInBucket = this._bucketSize - _firstInBucket - 1;
+        return this;
+    }
+    unique() {
+        if (this.size <= 1) {
+            return this.size;
+        }
+        let index = 1;
+        let prev = this.getAt(0);
+        for (let i = 1; i < this.size; ++i) {
+            const cur = this.getAt(i);
+            if (cur !== prev) {
+                prev = cur;
+                this.setAt(index++, cur);
+            }
+        }
+        this.cut(index - 1);
+        return this.size;
+    }
+    sort(comparator) {
+        const arr = [];
+        for (let i = 0; i < this.size; ++i) {
+            arr.push(this.getAt(i));
+        }
+        arr.sort(comparator);
+        for (let i = 0; i < this.size; ++i) {
+            this.setAt(i, arr[i]);
+        }
+        return this;
+    }
+    shrinkToFit() {
+        if (this.size === 0)
+            return;
+        const newBuckets = [];
+        if (this._bucketFirst === this._bucketLast)
+            return;
+        else if (this._bucketFirst < this._bucketLast) {
+            for (let i = this._bucketFirst; i <= this._bucketLast; ++i) {
+                newBuckets.push(this._buckets[i]);
+            }
+        }
+        else {
+            for (let i = this._bucketFirst; i < this._bucketCount; ++i) {
+                newBuckets.push(this._buckets[i]);
+            }
+            for (let i = 0; i <= this._bucketLast; ++i) {
+                newBuckets.push(this._buckets[i]);
+            }
+        }
+        this._bucketFirst = 0;
+        this._bucketLast = newBuckets.length - 1;
+        this._buckets = newBuckets;
+    }
+    forEach(callback) {
+        for (let i = 0; i < this.size; ++i) {
+            callback(this.getAt(i), i, this);
+        }
+    }
+    find(callback) {
+        for (let i = 0; i < this.size; ++i) {
+            const element = this.getAt(i);
+            if (callback(element, i, this)) {
+                return element;
+            }
+        }
+        return undefined;
+    }
+    toArray() {
+        const arr = [];
+        for (let i = 0; i < this.size; ++i) {
+            arr.push(this.getAt(i));
+        }
+        return arr;
+    }
+    map(callback) {
+        const newDeque = new Deque([], this._bucketSize);
+        for (let i = 0; i < this.size; ++i) {
+            newDeque.push(callback(this.getAt(i), i, this));
+        }
+        return newDeque;
+    }
+    filter(predicate) {
+        const newDeque = new Deque([], this._bucketSize);
+        for (let i = 0; i < this.size; ++i) {
+            const element = this.getAt(i);
+            if (predicate(element, i, this)) {
+                newDeque.push(element);
+            }
+        }
+        return newDeque;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        for (let i = 0; i < this.size; ++i) {
+            accumulator = callback(accumulator, this.getAt(i), i, this);
+        }
+        return accumulator;
+    }
+    indexOf(element) {
+        for (let i = 0; i < this.size; ++i) {
+            if (this.getAt(i) === element) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    *[Symbol.iterator]() {
+        for (let i = 0; i < this.size; ++i) {
+            yield this.getAt(i);
+        }
+    }
+    _reallocate(needBucketNum) {
+        const newBuckets = [];
+        const addBucketNum = needBucketNum || this._bucketCount >> 1 || 1;
+        for (let i = 0; i < addBucketNum; ++i) {
+            newBuckets[i] = new Array(this._bucketSize);
+        }
+        for (let i = this._bucketFirst; i < this._bucketCount; ++i) {
+            newBuckets[newBuckets.length] = this._buckets[i];
+        }
+        for (let i = 0; i < this._bucketLast; ++i) {
+            newBuckets[newBuckets.length] = this._buckets[i];
+        }
+        newBuckets[newBuckets.length] = [...this._buckets[this._bucketLast]];
+        this._bucketFirst = addBucketNum;
+        this._bucketLast = newBuckets.length - 1;
+        for (let i = 0; i < addBucketNum; ++i) {
+            newBuckets[newBuckets.length] = new Array(this._bucketSize);
+        }
+        this._buckets = newBuckets;
+        this._bucketCount = newBuckets.length;
+    }
+    _getBucketAndPosition(pos) {
+        let bucketIndex;
+        let indexInBucket;
+        const overallIndex = this._firstInBucket + pos;
+        bucketIndex = this._bucketFirst + Math.floor(overallIndex / this._bucketSize);
+        if (bucketIndex >= this._bucketCount) {
+            bucketIndex -= this._bucketCount;
+        }
+        indexInBucket = (overallIndex + 1) % this._bucketSize - 1;
+        if (indexInBucket < 0) {
+            indexInBucket = this._bucketSize - 1;
+        }
+        return { bucketIndex, indexInBucket };
+    }
 }
 exports.Deque = Deque;
-// O(1) time complexity of obtaining the value
+// O(1) time complexity of obtaining the element
 // O(n) time complexity of adding at the beginning and the end
 // todo tested slowest one
 class ObjectDeque {
@@ -50,11 +569,11 @@ class ObjectDeque {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The "addFirst" function adds a value to the beginning of an array-like data structure.
-     * @param {E} value - The `value` parameter represents the value that you want to add to the beginning of the data
+     * The "addFirst" function adds an element to the beginning of an array-like data structure.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
      * structure.
      */
-    addFirst(value) {
+    addFirst(element) {
         if (this.size === 0) {
             const mid = Math.floor(this.capacity / 2);
             this._first = mid;
@@ -63,7 +582,7 @@ class ObjectDeque {
         else {
             this._first--;
         }
-        this.nodes[this.first] = value;
+        this.nodes[this.first] = element;
         this._size++;
     }
     /**
@@ -74,10 +593,10 @@ class ObjectDeque {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The addLast function adds a value to the end of an array-like data structure.
-     * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
+     * The addLast function adds an element to the end of an array-like data structure.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
      */
-    addLast(value) {
+    addLast(element) {
         if (this.size === 0) {
             const mid = Math.floor(this.capacity / 2);
             this._first = mid;
@@ -86,7 +605,7 @@ class ObjectDeque {
         else {
             this._last++;
         }
-        this.nodes[this.last] = value;
+        this.nodes[this.last] = element;
         this._size++;
     }
     /**
@@ -98,16 +617,16 @@ class ObjectDeque {
      * Space Complexity: O(1)
      *
      * The function `popFirst()` removes and returns the first element in a data structure.
-     * @returns The value of the first element in the data structure.
+     * @returns The element of the first element in the data structure.
      */
     popFirst() {
         if (!this.size)
             return;
-        const value = this.getFirst();
+        const element = this.getFirst();
         delete this.nodes[this.first];
         this._first++;
         this._size--;
-        return value;
+        return element;
     }
     /**
      * Time Complexity: O(1)
@@ -133,16 +652,16 @@ class ObjectDeque {
      * Space Complexity: O(1)
      *
      * The `popLast()` function removes and returns the last element in a data structure.
-     * @returns The value that was removed from the data structure.
+     * @returns The element that was removed from the data structure.
      */
     popLast() {
         if (!this.size)
             return;
-        const value = this.getLast();
+        const element = this.getLast();
         delete this.nodes[this.last];
         this._last--;
         this._size--;
-        return value;
+        return element;
     }
     /**
      * Time Complexity: O(1)
@@ -171,204 +690,17 @@ class ObjectDeque {
      * @param {number} index - The index parameter is a number that represents the position of the element you want to
      * retrieve from the array.
      * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-     * index, `null` is returned.
+     * index, `undefined` is returned.
      */
     get(index) {
-        return this.nodes[this.first + index] || null;
+        return this.nodes[this.first + index] || undefined;
     }
     /**
      * The function checks if the size of a data structure is less than or equal to zero.
-     * @returns The method is returning a boolean value indicating whether the size of the object is less than or equal to 0.
+     * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
      */
     isEmpty() {
         return this.size <= 0;
     }
 }
 exports.ObjectDeque = ObjectDeque;
-// O(1) time complexity of obtaining the value
-// O(n) time complexity of adding at the beginning and the end
-class ArrayDeque {
-    constructor() {
-        this._nodes = [];
-    }
-    get nodes() {
-        return this._nodes;
-    }
-    get size() {
-        return this.nodes.length;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function "addLast" adds a value to the end of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the end of the array.
-     * @returns The return value is the new length of the array after the value has been added.
-     */
-    addLast(value) {
-        return this.nodes.push(value);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
-     * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
-     */
-    popLast() {
-        var _a;
-        return (_a = this.nodes.pop()) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
-     * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
-     * empty.
-     */
-    popFirst() {
-        var _a;
-        return (_a = this.nodes.shift()) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function "addFirst" adds a value to the beginning of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the beginning of the array.
-     * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
-     * `value` at the beginning.
-     */
-    addFirst(value) {
-        return this.nodes.unshift(value);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getFirst` function returns the first element of an array or null if the array is empty.
-     * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
-     * empty, it will return `null`.
-     */
-    getFirst() {
-        var _a;
-        return (_a = this.nodes[0]) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getLast` function returns the last element of an array or null if the array is empty.
-     * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
-     */
-    getLast() {
-        var _a;
-        return (_a = this.nodes[this.nodes.length - 1]) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The get function returns the element at the specified index in an array, or null if the index is out of bounds.
-     * @param {number} index - The index parameter is a number that represents the position of the element you want to
-     * retrieve from the array.
-     * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
-     * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
-     */
-    get(index) {
-        var _a;
-        return (_a = this.nodes[index]) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The set function assigns a value to a specific index in an array.
-     * @param {number} index - The index parameter is a number that represents the position of the element in the array
-     * that you want to set a new value for.
-     * @param {E} value - The value parameter represents the new value that you want to set at the specified index in the
-     * _nodes array.
-     * @returns The value that is being set at the specified index in the `_nodes` array.
-     */
-    set(index, value) {
-        return (this.nodes[index] = value);
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The insert function adds a value at a specified index in an array.
-     * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
-     * array. It is a number that represents the index of the array where the value should be inserted. The index starts
-     * from 0, so the first element of the array has an index of 0, the second element has
-     * @param {E} value - The value parameter represents the value that you want to insert into the array at the specified
-     * index.
-     * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
-     * are being removed, an empty array will be returned.
-     */
-    insert(index, value) {
-        return this.nodes.splice(index, 0, value);
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The delete function removes an element from an array at a specified index.
-     * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
-     * is a number that represents the index of the element to be removed.
-     * @returns The method is returning an array containing the removed element.
-     */
-    delete(index) {
-        return this.nodes.splice(index, 1);
-    }
-    /**
-     * The function checks if an array called "_nodes" is empty.
-     * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array
-     * is 0, indicating that the array is empty. Otherwise, it returns `false`.
-     */
-    isEmpty() {
-        return this.nodes.length === 0;
-    }
-}
-exports.ArrayDeque = ArrayDeque;