data-structure-typed 1.19.3 → 1.19.4

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

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayDeque = exports.ObjectDeque = exports.Deque = void 0;
 /**
@@ -23,22 +8,17 @@ exports.ArrayDeque = exports.ObjectDeque = exports.Deque = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-var linked_list_1 = require("../linked-list");
+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
-var Deque = /** @class */ (function (_super) {
-    __extends(Deque, _super);
-    function Deque() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return Deque;
-}(linked_list_1.DoublyLinkedList));
+class Deque extends linked_list_1.DoublyLinkedList {
+}
 exports.Deque = Deque;
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
 // todo tested slowest one
-var ObjectDeque = /** @class */ (function () {
-    function ObjectDeque(capacity) {
+class ObjectDeque {
+    constructor(capacity) {
         this._nodes = {};
         this._capacity = Number.MAX_SAFE_INTEGER;
         this._first = -1;
@@ -47,53 +27,33 @@ var ObjectDeque = /** @class */ (function () {
         if (capacity !== undefined)
             this._capacity = capacity;
     }
-    Object.defineProperty(ObjectDeque.prototype, "nodes", {
-        get: function () {
-            return this._nodes;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ObjectDeque.prototype, "capacity", {
-        get: function () {
-            return this._capacity;
-        },
-        set: function (value) {
-            this._capacity = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ObjectDeque.prototype, "first", {
-        get: function () {
-            return this._first;
-        },
-        set: function (value) {
-            this._first = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ObjectDeque.prototype, "last", {
-        get: function () {
-            return this._last;
-        },
-        set: function (value) {
-            this._last = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ObjectDeque.prototype, "size", {
-        get: function () {
-            return this._size;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ObjectDeque.prototype.addFirst = function (value) {
+    get nodes() {
+        return this._nodes;
+    }
+    get capacity() {
+        return this._capacity;
+    }
+    set capacity(value) {
+        this._capacity = value;
+    }
+    get first() {
+        return this._first;
+    }
+    set first(value) {
+        this._first = value;
+    }
+    get last() {
+        return this._last;
+    }
+    set last(value) {
+        this._last = value;
+    }
+    get size() {
+        return this._size;
+    }
+    addFirst(value) {
         if (this._size === 0) {
-            var mid = Math.floor(this._capacity / 2);
+            const mid = Math.floor(this._capacity / 2);
             this._first = mid;
             this._last = mid;
         }
@@ -102,10 +62,10 @@ var ObjectDeque = /** @class */ (function () {
         }
         this._nodes[this._first] = value;
         this._size++;
-    };
-    ObjectDeque.prototype.addLast = function (value) {
+    }
+    addLast(value) {
         if (this._size === 0) {
-            var mid = Math.floor(this._capacity / 2);
+            const mid = Math.floor(this._capacity / 2);
             this._first = mid;
             this._last = mid;
         }
@@ -114,112 +74,107 @@ var ObjectDeque = /** @class */ (function () {
         }
         this._nodes[this._last] = value;
         this._size++;
-    };
-    ObjectDeque.prototype.pollFirst = function () {
+    }
+    pollFirst() {
         if (!this._size)
             return;
-        var value = this.peekFirst();
+        const value = this.peekFirst();
         delete this._nodes[this._first];
         this._first++;
         this._size--;
         return value;
-    };
-    ObjectDeque.prototype.peekFirst = function () {
+    }
+    peekFirst() {
         if (this._size)
             return this._nodes[this._first];
-    };
-    ObjectDeque.prototype.pollLast = function () {
+    }
+    pollLast() {
         if (!this._size)
             return;
-        var value = this.peekLast();
+        const value = this.peekLast();
         delete this._nodes[this._last];
         this._last--;
         this._size--;
         return value;
-    };
-    ObjectDeque.prototype.peekLast = function () {
+    }
+    peekLast() {
         if (this._size)
             return this._nodes[this._last];
-    };
-    ObjectDeque.prototype.get = function (index) {
+    }
+    get(index) {
         return this._nodes[this._first + index] || null;
-    };
-    ObjectDeque.prototype.isEmpty = function () {
+    }
+    isEmpty() {
         return this._size <= 0;
-    };
-    ObjectDeque.prototype._seNodes = function (value) {
+    }
+    _seNodes(value) {
         this._nodes = value;
-    };
-    ObjectDeque.prototype._setSize = function (value) {
+    }
+    _setSize(value) {
         this._size = value;
-    };
-    return ObjectDeque;
-}());
+    }
+}
 exports.ObjectDeque = ObjectDeque;
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
-var ArrayDeque = /** @class */ (function () {
-    function ArrayDeque() {
+class ArrayDeque {
+    constructor() {
         this._nodes = [];
     }
-    Object.defineProperty(ArrayDeque.prototype, "size", {
-        get: function () {
-            return this._nodes.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    get size() {
+        return this._nodes.length;
+    }
     /**
      * The function "addLast" adds a value to the end of an array.
      * @param {T} 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.
      */
-    ArrayDeque.prototype.addLast = function (value) {
+    addLast(value) {
         return this._nodes.push(value);
-    };
+    }
     /**
      * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
      * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    ArrayDeque.prototype.pollLast = function () {
+    pollLast() {
         var _a;
         return (_a = this._nodes.pop()) !== null && _a !== void 0 ? _a : null;
-    };
+    }
     /**
      * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
      * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
      * empty.
      */
-    ArrayDeque.prototype.pollFirst = function () {
+    pollFirst() {
         var _a;
         return (_a = this._nodes.shift()) !== null && _a !== void 0 ? _a : null;
-    };
+    }
     /**
      * The function "addFirst" adds a value to the beginning of an array.
      * @param {T} 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.
      */
-    ArrayDeque.prototype.addFirst = function (value) {
+    addFirst(value) {
         return this._nodes.unshift(value);
-    };
+    }
     /**
      * The `peekFirst` function returns the first element of an array or null if the array is empty.
      * @returns The function `peekFirst()` is returning the first element (`T`) of the `_nodes` array. If the array is
      * empty, it will return `null`.
      */
-    ArrayDeque.prototype.peekFirst = function () {
+    peekFirst() {
         var _a;
         return (_a = this._nodes[0]) !== null && _a !== void 0 ? _a : null;
-    };
+    }
     /**
      * The `peekLast` function returns the last element of an array or null if the array is empty.
      * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    ArrayDeque.prototype.peekLast = function () {
+    peekLast() {
         var _a;
         return (_a = this._nodes[this._nodes.length - 1]) !== null && _a !== void 0 ? _a : null;
-    };
+    }
     /**
      * 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
@@ -227,10 +182,10 @@ var ArrayDeque = /** @class */ (function () {
      * @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.
      */
-    ArrayDeque.prototype.get = function (index) {
+    get(index) {
         var _a;
         return (_a = this._nodes[index]) !== null && _a !== void 0 ? _a : null;
-    };
+    }
     /**
      * 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
@@ -239,9 +194,9 @@ var ArrayDeque = /** @class */ (function () {
      * _nodes array.
      * @returns The value that is being set at the specified index in the `_nodes` array.
      */
-    ArrayDeque.prototype.set = function (index, value) {
+    set(index, value) {
         return this._nodes[index] = value;
-    };
+    }
     /**
      * 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
@@ -252,26 +207,25 @@ var ArrayDeque = /** @class */ (function () {
      * @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.
      */
-    ArrayDeque.prototype.insert = function (index, value) {
+    insert(index, value) {
         return this._nodes.splice(index, 0, value);
-    };
+    }
     /**
      * The remove 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.
      */
-    ArrayDeque.prototype.remove = function (index) {
+    remove(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`.
      */
-    ArrayDeque.prototype.isEmpty = function () {
+    isEmpty() {
         return this._nodes.length === 0;
-    };
-    return ArrayDeque;
-}());
+    }
+}
 exports.ArrayDeque = ArrayDeque;

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

@@ -6,14 +6,14 @@ exports.Queue = void 0;
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-var Queue = /** @class */ (function () {
+class Queue {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
      * @param {T[]} [elements] - The `elements` parameter is an optional array of elements of type `T`. If provided, it
      * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
      * initialized as an empty array.
      */
-    function Queue(elements) {
+    constructor(elements) {
         this._nodes = elements || [];
         this._offset = 0;
     }
@@ -25,27 +25,27 @@ var Queue = /** @class */ (function () {
      * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
      * array.
      */
-    Queue.fromArray = function (elements) {
+    static fromArray(elements) {
         return new Queue(elements);
-    };
+    }
     /**
      * The add function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
      * @param {T} element - The `element` parameter represents the element that you want to add to the queue.
      * @returns The `add` method is returning a `Queue<T>` object.
      */
-    Queue.prototype.add = function (element) {
+    add(element) {
         this._nodes.push(element);
         return this;
-    };
+    }
     /**
      * The `poll` function removes and returns the first element in the queue, and adjusts the internal data structure if
      * necessary to optimize performance.
      * @returns The function `poll()` returns either the first element in the queue or `null` if the queue is empty.
      */
-    Queue.prototype.poll = function () {
+    poll() {
         if (this.size() === 0)
             return null;
-        var first = this.peek();
+        const first = this.peek();
         this._offset += 1;
         if (this._offset * 2 < this._nodes.length)
             return first;
@@ -54,58 +54,57 @@ var Queue = /** @class */ (function () {
         this._nodes = this._nodes.slice(this._offset);
         this._offset = 0;
         return first;
-    };
+    }
     /**
      * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
      * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
      */
-    Queue.prototype.peek = function () {
+    peek() {
         return this.size() > 0 ? this._nodes[this._offset] : null;
-    };
+    }
     /**
      * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
      * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `null`.
      */
-    Queue.prototype.peekLast = function () {
+    peekLast() {
         return this.size() > 0 ? this._nodes[this._nodes.length - 1] : null;
-    };
+    }
     /**
      * The size function returns the number of elements in an array.
      * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
      */
-    Queue.prototype.size = function () {
+    size() {
         return this._nodes.length - this._offset;
-    };
+    }
     /**
      * The function checks if a data structure is empty by comparing its size to zero.
      * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
      */
-    Queue.prototype.isEmpty = function () {
+    isEmpty() {
         return this.size() === 0;
-    };
+    }
     /**
      * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
      * @returns An array of type T is being returned.
      */
-    Queue.prototype.toArray = function () {
+    toArray() {
         return this._nodes.slice(this._offset);
-    };
+    }
     /**
      * The clear function resets the nodes array and offset to their initial values.
      */
-    Queue.prototype.clear = function () {
+    clear() {
         this._nodes = [];
         this._offset = 0;
-    };
+    }
     /**
      * The `clone()` function returns a new Queue object with the same elements as the original Queue.
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
-    Queue.prototype.clone = function () {
+    clone() {
         return new Queue(this._nodes.slice(this._offset));
-    };
-    return Queue;
-}());
+    }
+}
 exports.Queue = Queue;

package/dist/data-structures/stack/stack.js

@@ -6,14 +6,14 @@ exports.Stack = void 0;
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-var Stack = /** @class */ (function () {
+class Stack {
     /**
      * The constructor initializes an array of elements, which can be provided as an optional parameter.
      * @param {T[]} [elements] - The `elements` parameter is an optional parameter of type `T[]`, which represents an array
      * of elements of type `T`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
      * is provided and is an array, it is assigned to the `_elements
      */
-    function Stack(elements) {
+    constructor(elements) {
         this._elements = Array.isArray(elements) ? elements : [];
     }
     /**
@@ -22,71 +22,70 @@ var Stack = /** @class */ (function () {
      * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
      * array.
      */
-    Stack.fromArray = function (elements) {
+    static fromArray(elements) {
         return new Stack(elements);
-    };
+    }
     /**
      * The function checks if an array is empty and returns a boolean value.
      * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
-    Stack.prototype.isEmpty = function () {
+    isEmpty() {
         return this._elements.length === 0;
-    };
+    }
     /**
      * The size() function returns the number of elements in an array.
      * @returns The size of the elements array.
      */
-    Stack.prototype.size = function () {
+    size() {
         return this._elements.length;
-    };
+    }
     /**
      * The `peek` function returns the last element of an array, or null if the array is empty.
      * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
      */
-    Stack.prototype.peek = function () {
+    peek() {
         if (this.isEmpty())
             return null;
         return this._elements[this._elements.length - 1];
-    };
+    }
     /**
      * The push function adds an element to the stack and returns the updated stack.
      * @param {T} element - The parameter "element" is of type T, which means it can be any data type.
      * @returns The `push` method is returning the updated `Stack<T>` object.
      */
-    Stack.prototype.push = function (element) {
+    push(element) {
         this._elements.push(element);
         return this;
-    };
+    }
     /**
      * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
      * array is empty, it returns `null`.
      */
-    Stack.prototype.pop = function () {
+    pop() {
         if (this.isEmpty())
             return null;
         return this._elements.pop() || null;
-    };
+    }
     /**
      * The toArray function returns a copy of the elements in an array.
      * @returns An array of type T.
      */
-    Stack.prototype.toArray = function () {
+    toArray() {
         return this._elements.slice();
-    };
+    }
     /**
      * The clear function clears the elements array.
      */
-    Stack.prototype.clear = function () {
+    clear() {
         this._elements = [];
-    };
+    }
     /**
      * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
-    Stack.prototype.clone = function () {
+    clone() {
         return new Stack(this._elements.slice());
-    };
-    return Stack;
-}());
+    }
+}
 exports.Stack = Stack;