data-structure-typed 2.0.0 → 2.0.1

package/dist/individuals/queue/deque.mjs

@@ -0,0 +1,1262 @@
+// src/utils/utils.ts
+var THUNK_SYMBOL = Symbol("thunk");
+var rangeCheck = (index, min, max, message = "Index out of bounds.") => {
+  if (index < min || index > max) throw new RangeError(message);
+};
+var calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
+
+// src/data-structures/base/iterable-element-base.ts
+var IterableElementBase = class {
+  /**
+   * The protected constructor initializes the options for the IterableElementBase class, including the
+   * toElementFn function.
+   * @param [options] - An optional object that contains the following properties:
+   */
+  constructor(options) {
+    if (options) {
+      const { toElementFn } = options;
+      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
+      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+    }
+  }
+  _toElementFn;
+  get toElementFn() {
+    return this._toElementFn;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function is an implementation of the Symbol.iterator method that returns an IterableIterator.
+   * @param {any[]} args - The `args` parameter in the code snippet represents a rest parameter. It
+   * allows the function to accept any number of arguments as an array. In this case, the `args`
+   * parameter is used to pass any number of arguments to the `_getIterator` method.
+   */
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The function returns an iterator that yields all the values in the object.
+   */
+  *values() {
+    for (const item of this) {
+      yield item;
+    }
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `every` function checks if every element in the array satisfies a given predicate.
+   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+   * the current element being processed, its index, and the array it belongs to. It should return a
+   * boolean value indicating whether the element satisfies a certain condition or not.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+   * passed as the `this` value to the `predicate` function. If `thisArg` is
+   * @returns The `every` method is returning a boolean value. It returns `true` if every element in
+   * the array satisfies the provided predicate function, and `false` otherwise.
+   */
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (!predicate.call(thisArg, item, index++, this)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The "some" function checks if at least one element in a collection satisfies a given predicate.
+   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+   * `value`, `index`, and `array`. It should return a boolean value indicating whether the current
+   * element satisfies the condition.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
+   * it will be passed as the `this` value to the `predicate` function. If `thisArg
+   * @returns a boolean value. It returns true if the predicate function returns true for any element
+   * in the collection, and false otherwise.
+   */
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (predicate.call(thisArg, item, index++, this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `forEach` function iterates over each element in an array-like object and calls a callback
+   * function for each element.
+   * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+   * the array. It takes three arguments: the current element being processed, the index of the current
+   * element, and the array that forEach was called upon.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+   * be passed as the `this` value to the `callbackfn` function. If `thisArg
+   */
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      callbackfn.call(thisArg, item, index++, this);
+    }
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `find` function iterates over the elements of an array-like object and returns the first
+   * element that satisfies the provided callback function.
+   * @param predicate - The predicate parameter is a function that will be called for each element in
+   * the array. It takes three arguments: the current element being processed, the index of the current
+   * element, and the array itself. The function should return a boolean value indicating whether the
+   * current element matches the desired condition.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+   * be passed as the `this` value to the `callbackfn` function. If `thisArg
+   * @returns The `find` method returns the first element in the array that satisfies the provided
+   * callback function. If no element satisfies the callback function, `undefined` is returned.
+   */
+  find(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (predicate.call(thisArg, item, index++, this)) return item;
+    }
+    return;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function checks if a given element exists in a collection.
+   * @param {E} element - The parameter "element" is of type E, which means it can be any type. It
+   * represents the element that we want to check for existence in the collection.
+   * @returns a boolean value. It returns true if the element is found in the collection, and false
+   * otherwise.
+   */
+  has(element) {
+    for (const ele of this) {
+      if (ele === element) return true;
+    }
+    return false;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `reduce` function iterates over the elements of an array-like object and applies a callback
+   * function to reduce them into a single value.
+   * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+   * the array. It takes four arguments:
+   * @param {U} initialValue - The initialValue parameter is the initial value of the accumulator. It
+   * is the value that the accumulator starts with before the reduction operation begins.
+   * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+   * all the elements in the array and applying the callback function to each element.
+   */
+  reduce(callbackfn, initialValue) {
+    let accumulator = initialValue ?? 0;
+    let index = 0;
+    for (const item of this) {
+      accumulator = callbackfn(accumulator, item, index++, this);
+    }
+    return accumulator;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `toArray` function converts a linked list into an array.
+   * @returns The `toArray()` method is returning an array of type `E[]`.
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The print function logs the elements of an array to the console.
+   */
+  toVisual() {
+    return [...this];
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The print function logs the elements of an array to the console.
+   */
+  print() {
+    console.log(this.toVisual());
+  }
+};
+
+// src/data-structures/base/linear-base.ts
+var LinearBase = class _LinearBase extends IterableElementBase {
+  /**
+   * The constructor initializes the LinearBase class with optional options, setting the maximum length
+   * if provided.
+   * @param [options] - The `options` parameter is an optional object that can be passed to the
+   * constructor. It is of type `LinearBaseOptions<E, R>`. The constructor checks if the `options`
+   * object is provided and then extracts the `maxLen` property from it. If `maxLen` is a
+   */
+  constructor(options) {
+    super(options);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+  _maxLen = -1;
+  get maxLen() {
+    return this._maxLen;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function indexOf searches for a specified element starting from a given index in an array-like
+   * object and returns the index of the first occurrence, or -1 if not found.
+   * @param {E} searchElement - The `searchElement` parameter in the `indexOf` function represents the
+   * element that you want to find within the array. The function will search for this element starting
+   * from the `fromIndex` (if provided) up to the end of the array. If the `searchElement` is found
+   * within the
+   * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` function represents the
+   * index at which to start searching for the `searchElement` within the array. If provided, the
+   * search will begin at this index and continue to the end of the array. If `fromIndex` is not
+   * specified, the default
+   * @returns The `indexOf` method is returning the index of the `searchElement` if it is found in the
+   * array starting from the `fromIndex`. If the `searchElement` is not found, it returns -1.
+   */
+  indexOf(searchElement, fromIndex = 0) {
+    if (this.length === 0) return -1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    if (fromIndex < 0) fromIndex = 0;
+    for (let i = fromIndex; i < this.length; i++) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function `lastIndexOf` in TypeScript returns the index of the last occurrence of a specified
+   * element in an array.
+   * @param {E} searchElement - The `searchElement` parameter is the element that you want to find the
+   * last index of within the array. The `lastIndexOf` method will search the array starting from the
+   * `fromIndex` (or the end of the array if not specified) and return the index of the last occurrence
+   * of the
+   * @param {number} fromIndex - The `fromIndex` parameter in the `lastIndexOf` method specifies the
+   * index at which to start searching for the `searchElement` in the array. By default, it starts
+   * searching from the last element of the array (`this.length - 1`). If a specific `fromIndex` is
+   * provided
+   * @returns The last index of the `searchElement` in the array is being returned. If the
+   * `searchElement` is not found in the array, -1 is returned.
+   */
+  lastIndexOf(searchElement, fromIndex = this.length - 1) {
+    if (this.length === 0) return -1;
+    if (fromIndex >= this.length) fromIndex = this.length - 1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    for (let i = fromIndex; i >= 0; i--) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `findIndex` function iterates over an array and returns the index of the first element that
+   * satisfies the provided predicate function.
+   * @param predicate - The `predicate` parameter in the `findIndex` function is a callback function
+   * that takes three arguments: `item`, `index`, and the array `this`. It should return a boolean
+   * value indicating whether the current element satisfies the condition being checked for.
+   * @param {any} [thisArg] - The `thisArg` parameter in the `findIndex` function is an optional
+   * parameter that specifies the value to use as `this` when executing the `predicate` function. If
+   * provided, the `predicate` function will be called with `thisArg` as its `this` value. If `
+   * @returns The `findIndex` method is returning the index of the first element in the array that
+   * satisfies the provided predicate function. If no such element is found, it returns -1.
+   */
+  findIndex(predicate, thisArg) {
+    for (let i = 0; i < this.length; i++) {
+      const item = this.at(i);
+      if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
+    }
+    return -1;
+  }
+  /**
+   * Time Complexity: O(n + m)
+   * Space Complexity: O(n + m)
+   *
+   * The `concat` function in TypeScript concatenates multiple items into a new list, handling both
+   * individual elements and instances of `LinearBase`.
+   * @param {(E | this)[]} items - The `concat` method takes in an array of items, where
+   * each item can be either of type `E` or an instance of `LinearBase<E, R>`.
+   * @returns The `concat` method is returning a new instance of the class that it belongs to, with the
+   * items passed as arguments concatenated to it.
+   */
+  concat(...items) {
+    const newList = this.clone();
+    for (const item of items) {
+      if (item instanceof _LinearBase) {
+        newList.pushMany(item);
+      } else {
+        newList.push(item);
+      }
+    }
+    return newList;
+  }
+  /**
+   * Time Complexity: O(n log n)
+   * Space Complexity: O(n)
+   *
+   * The `sort` function in TypeScript sorts the elements of a collection using a specified comparison
+   * function.
+   * @param [compareFn] - The `compareFn` parameter is a function that defines the sort order. It takes
+   * two elements `a` and `b` as input and returns a number indicating their relative order. If the
+   * returned value is negative, `a` comes before `b`. If the returned value is positive, `
+   * @returns The `sort` method is returning the instance of the object on which it is called (this),
+   * after sorting the elements based on the provided comparison function (compareFn).
+   */
+  sort(compareFn) {
+    const arr = this.toArray();
+    arr.sort(compareFn);
+    this.clear();
+    for (const item of arr) this.push(item);
+    return this;
+  }
+  /**
+   * Time Complexity: O(n + m)
+   * Space Complexity: O(m)
+   *
+   * The `splice` function in TypeScript removes elements from an array and optionally inserts new
+   * elements at the specified index.
+   * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
+   * to start modifying the array. If `start` is a negative number, it will count from the end of the
+   * array.
+   * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+   * number of elements to remove from the array starting at the specified `start` index. If
+   * `deleteCount` is not provided or is 0, no elements are removed, and only new elements are inserted
+   * at the `start`
+   * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+   * will be inserted into the array at the specified `start` index. These elements can be of any type
+   * and you can pass multiple elements separated by commas. The `splice` method will insert these
+   * items into the array at the
+   * @returns The `splice` method returns a list of elements that were removed from the original list
+   * during the operation.
+   */
+  splice(start, deleteCount = 0, ...items) {
+    const removedList = this._createInstance();
+    start = start < 0 ? this.length + start : start;
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+    for (let i = 0; i < deleteCount; i++) {
+      const removed = this.deleteAt(start);
+      if (removed !== void 0) {
+        removedList.push(removed);
+      }
+    }
+    for (let i = 0; i < items.length; i++) {
+      this.addAt(start + i, items[i]);
+    }
+    return removedList;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `join` function in TypeScript returns a string by joining the elements of an array with a
+   * specified separator.
+   * @param {string} [separator=,] - The `separator` parameter is a string that specifies the character
+   * or characters that will be used to separate each element when joining them into a single string.
+   * By default, the separator is set to a comma (`,`), but you can provide a different separator if
+   * needed.
+   * @returns The `join` method is being returned, which takes an optional `separator` parameter
+   * (defaulting to a comma) and returns a string created by joining all elements of the array after
+   * converting it to an array.
+   */
+  join(separator = ",") {
+    return this.toArray().join(separator);
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The function `toReversedArray` takes an array and returns a new array with its elements in reverse
+   * order.
+   * @returns The `toReversedArray()` function returns an array of elements of type `E` in reverse
+   * order.
+   */
+  toReversedArray() {
+    const array = [];
+    for (let i = this.length - 1; i >= 0; i--) {
+      array.push(this.at(i));
+    }
+    return array;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `reduceRight` function in TypeScript iterates over an array from right to left and applies a
+   * callback function to each element, accumulating a single result.
+   * @param callbackfn - The `callbackfn` parameter in the `reduceRight` method is a function that will
+   * be called on each element in the array from right to left. It takes four arguments:
+   * @param {U} [initialValue] - The `initialValue` parameter in the `reduceRight` method is an
+   * optional parameter that specifies the initial value of the accumulator. If provided, the
+   * `accumulator` will start with this initial value before iterating over the elements of the array.
+   * If `initialValue` is not provided, the accumulator will
+   * @returns The `reduceRight` method is returning the final accumulated value after applying the
+   * callback function to each element in the array from right to left.
+   */
+  reduceRight(callbackfn, initialValue) {
+    let accumulator = initialValue ?? 0;
+    for (let i = this.length - 1; i >= 0; i--) {
+      accumulator = callbackfn(accumulator, this.at(i), i, this);
+    }
+    return accumulator;
+  }
+  /**
+   * Time Complexity: O(m)
+   * Space Complexity: O(m)
+   *
+   * The `slice` function in TypeScript creates a new instance by extracting a portion of elements from
+   * the original instance based on the specified start and end indices.
+   * @param {number} [start=0] - The `start` parameter in the `slice` method represents the index at
+   * which to begin extracting elements from an array-like object. If no `start` parameter is provided,
+   * the default value is 0, meaning the extraction will start from the beginning of the array.
+   * @param {number} end - The `end` parameter in the `slice` method represents the index at which to
+   * end the slicing. By default, if no `end` parameter is provided, it will slice until the end of the
+   * array (i.e., `this.length`).
+   * @returns The `slice` method is returning a new instance of the object with elements sliced from
+   * the specified start index (default is 0) to the specified end index (default is the length of the
+   * object).
+   */
+  slice(start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    const newList = this._createInstance();
+    for (let i = start; i < end; i++) {
+      newList.push(this.at(i));
+    }
+    return newList;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `fill` function in TypeScript fills a specified range in an array-like object with a given
+   * value.
+   * @param {E} value - The `value` parameter in the `fill` method represents the element that will be
+   * used to fill the specified range in the array.
+   * @param [start=0] - The `start` parameter specifies the index at which to start filling the array
+   * with the specified value. If not provided, it defaults to 0, indicating the beginning of the
+   * array.
+   * @param end - The `end` parameter in the `fill` function represents the index at which the filling
+   * of values should stop. It specifies the end of the range within the array where the `value` should
+   * be filled.
+   * @returns The `fill` method is returning the modified object (`this`) after filling the specified
+   * range with the provided value.
+   */
+  fill(value, start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    if (start < 0) start = 0;
+    if (end > this.length) end = this.length;
+    if (start >= end) return this;
+    for (let i = start; i < end; i++) {
+      this.setAt(i, value);
+    }
+    return this;
+  }
+};
+
+// src/data-structures/queue/deque.ts
+var Deque = class _Deque extends LinearBase {
+  /**
+   * The constructor initializes a Deque object with optional iterable of elements and options.
+   * @param elements - An iterable object (such as an array or a Set) that contains the initial
+   * elements to be added to the deque. It can also be an object with a `length` or `size` property
+   * that represents the number of elements in the iterable object. If no elements are provided, an
+   * empty deque
+   * @param {DequeOptions} [options] - The `options` parameter is an optional object that can contain
+   * configuration options for the deque. In this code, it is used to set the `bucketSize` option,
+   * which determines the size of each bucket in the deque. If the `bucketSize` option is not provided
+   * or is not a number
+   */
+  constructor(elements = [], options) {
+    super(options);
+    if (options) {
+      const { bucketSize } = options;
+      if (typeof bucketSize === "number") this._bucketSize = bucketSize;
+    }
+    let _size;
+    if ("length" in elements) {
+      if (elements.length instanceof Function) _size = elements.length();
+      else _size = elements.length;
+    } else {
+      if (elements.size instanceof Function) _size = elements.size();
+      else _size = elements.size;
+    }
+    this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
+    for (let i = 0; i < this._bucketCount; ++i) {
+      this._buckets.push(new Array(this._bucketSize));
+    }
+    const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);
+    this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
+    this._firstInBucket = this._lastInBucket = this._bucketSize - _size % this._bucketSize >> 1;
+    this.pushMany(elements);
+  }
+  _bucketSize = 1 << 12;
+  get bucketSize() {
+    return this._bucketSize;
+  }
+  _bucketFirst = 0;
+  get bucketFirst() {
+    return this._bucketFirst;
+  }
+  _firstInBucket = 0;
+  get firstInBucket() {
+    return this._firstInBucket;
+  }
+  _bucketLast = 0;
+  get bucketLast() {
+    return this._bucketLast;
+  }
+  _lastInBucket = 0;
+  get lastInBucket() {
+    return this._lastInBucket;
+  }
+  _bucketCount = 0;
+  get bucketCount() {
+    return this._bucketCount;
+  }
+  _buckets = [];
+  get buckets() {
+    return this._buckets;
+  }
+  _length = 0;
+  get length() {
+    return this._length;
+  }
+  /**
+   * The function returns the first element in a collection if it exists, otherwise it returns
+   * undefined.
+   * @returns The first element of the collection, of type E, is being returned.
+   */
+  get first() {
+    if (this._length === 0) return;
+    return this._buckets[this._bucketFirst][this._firstInBucket];
+  }
+  /**
+   * The last function returns the last element in the queue.
+   * @return The last element in the array
+   */
+  get last() {
+    if (this._length === 0) return;
+    return this._buckets[this._bucketLast][this._lastInBucket];
+  }
+  /**
+   * Time Complexity - Amortized O(1) (possible reallocation),
+   * Space Complexity - O(n) (due to potential resizing).
+   *
+   * The push function adds an element to a data structure and reallocates memory if necessary.
+   * @param {E} element - The `element` parameter represents the value that you want to add to the data
+   * structure.
+   * @returns The size of the data structure after the element has been pushed.
+   */
+  push(element) {
+    if (this._length) {
+      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._length += 1;
+    this._buckets[this._bucketLast][this._lastInBucket] = element;
+    if (this._maxLen > 0 && this._length > this._maxLen) this.shift();
+    return true;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The `pop()` function removes and returns the last element from a data structure, updating the
+   * internal state variables accordingly.
+   * @returns The element that was removed from the data structure is being returned.
+   */
+  pop() {
+    if (this._length === 0) return;
+    const element = this._buckets[this._bucketLast][this._lastInBucket];
+    if (this._length !== 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._length -= 1;
+    return element;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The `shift()` function removes and returns the first element from a data structure, updating the
+   * internal state variables accordingly.
+   * @returns The element that is being removed from the beginning of the data structure is being
+   * returned.
+   */
+  shift() {
+    if (this._length === 0) return;
+    const element = this._buckets[this._bucketFirst][this._firstInBucket];
+    if (this._length !== 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._length -= 1;
+    return element;
+  }
+  /**
+   * Time Complexity: Amortized O(1)
+   * Space Complexity: O(n)
+   *
+   * The `unshift` function adds an element to the beginning of an array-like data structure and
+   * returns the new size of the structure.
+   * @param {E} element - The `element` parameter represents the element that you want to add to the
+   * beginning of the data structure.
+   * @returns The size of the data structure after the element has been added.
+   */
+  unshift(element) {
+    if (this._length) {
+      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._length += 1;
+    this._buckets[this._bucketFirst][this._firstInBucket] = element;
+    if (this._maxLen > 0 && this._length > this._maxLen) this.pop();
+    return true;
+  }
+  /**
+   * Time Complexity: O(k)
+   * Space Complexity: O(k)
+   *
+   * The function `pushMany` iterates over elements and pushes them into an array after applying a
+   * transformation function if provided.
+   * @param {IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>} elements - The `elements`
+   * parameter in the `pushMany` function is expected to be an iterable containing elements of type `E`
+   * or `R`. It can be either an `IterableWithSizeOrLength<E>` or an `IterableWithSizeOrLength<R>`. The
+   * function iterates over each element
+   * @returns The `pushMany` function is returning an array of boolean values, where each value
+   * represents the result of calling the `push` method on the current object instance with the
+   * corresponding element from the input `elements` iterable.
+   */
+  pushMany(elements) {
+    const ans = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.push(this.toElementFn(el)));
+      } else {
+        ans.push(this.push(el));
+      }
+    }
+    return ans;
+  }
+  /**
+   * Time Complexity: O(k)
+   * Space Complexity: O(k)
+   *
+   * The `unshiftMany` function in TypeScript iterates over elements and adds them to the beginning of
+   * an array, optionally converting them using a provided function.
+   * @param {IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>} elements - The `elements`
+   * parameter in the `unshiftMany` function is an iterable containing elements of type `E` or `R`. It
+   * can be an array or any other iterable data structure that has a known size or length. The function
+   * iterates over each element in the `elements` iterable and
+   * @returns The `unshiftMany` function returns an array of boolean values indicating whether each
+   * element was successfully added to the beginning of the array.
+   */
+  unshiftMany(elements = []) {
+    const ans = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.unshift(this.toElementFn(el)));
+      } else {
+        ans.push(this.unshift(el));
+      }
+    }
+    return ans;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function checks if the size of an object is equal to zero and returns a boolean value.
+   * @returns A boolean value indicating whether the size of the object is 0 or not.
+   */
+  isEmpty() {
+    return this._length === 0;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The clear() function resets the state of the object by initializing all variables to their default
+   * values.
+   */
+  clear() {
+    this._buckets = [new Array(this._bucketSize)];
+    this._bucketCount = 1;
+    this._bucketFirst = this._bucketLast = this._length = 0;
+    this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The `at` function retrieves an element at a specified position in an array-like data structure.
+   * @param {number} pos - The `pos` parameter represents the position of the element that you want to
+   * retrieve from the data structure. It is of type `number` and should be a valid index within the
+   * range of the data structure.
+   * @returns The element at the specified position in the data structure is being returned.
+   */
+  at(pos) {
+    rangeCheck(pos, 0, this._length - 1);
+    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+    return this._buckets[bucketIndex][indexInBucket];
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The `setAt` function sets an element at a specific position in an array-like data structure.
+   * @param {number} pos - The `pos` parameter represents the position at which the element needs to be
+   * set. It is of type `number`.
+   * @param {E} element - The `element` parameter is the value that you want to set at the specified
+   * position in the data structure.
+   */
+  setAt(pos, element) {
+    rangeCheck(pos, 0, this._length - 1);
+    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+    this._buckets[bucketIndex][indexInBucket] = element;
+    return true;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `addAt` function inserts one or more elements at a specified position in an array-like data
+   * structure.
+   * @param {number} pos - The `pos` parameter represents the position at which the element(s) should
+   * be inserted. It is of type `number`.
+   * @param {E} element - The `element` parameter represents the element that you want to insert into
+   * the array at the specified position.
+   * @param [num=1] - The `num` parameter represents the number of times the `element` should be
+   * inserted at the specified position (`pos`). By default, it is set to 1, meaning that the `element`
+   * will be inserted once. However, you can provide a different value for `num` if you want
+   * @returns The size of the array after the insertion is being returned.
+   */
+  addAt(pos, element, num = 1) {
+    const length = this._length;
+    rangeCheck(pos, 0, length);
+    if (pos === 0) {
+      while (num--) this.unshift(element);
+    } else if (pos === this._length) {
+      while (num--) this.push(element);
+    } else {
+      const arr = [];
+      for (let i = pos; i < this._length; ++i) {
+        arr.push(this.at(i));
+      }
+      this.cut(pos - 1, true);
+      for (let i = 0; i < num; ++i) this.push(element);
+      for (let i = 0; i < arr.length; ++i) this.push(arr[i]);
+    }
+    return true;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The `cut` function updates the state of the object based on the given position and returns the
+   * updated size.
+   * @param {number} pos - The `pos` parameter represents the position at which the string should be
+   * cut. It is a number that indicates the index of the character where the cut should be made.
+   * @param {boolean} isCutSelf - If true, the original deque will not be cut, and return a new deque
+   * @returns The method is returning the updated size of the data structure.
+   */
+  cut(pos, isCutSelf = false) {
+    if (isCutSelf) {
+      if (pos < 0) {
+        this.clear();
+        return this;
+      }
+      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+      this._bucketLast = bucketIndex;
+      this._lastInBucket = indexInBucket;
+      this._length = pos + 1;
+      return this;
+    } else {
+      const newDeque = this._createInstance({
+        bucketSize: this._bucketSize,
+        toElementFn: this._toElementFn,
+        maxLen: this._maxLen
+      });
+      for (let i = 0; i <= pos; i++) {
+        newDeque.push(this.at(i));
+      }
+      return newDeque;
+    }
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `splice` function in TypeScript overrides the default behavior to remove and insert elements
+   * in a Deque data structure while ensuring the starting position and delete count are within bounds.
+   * @param {number} start - The `start` parameter in the `splice` method represents the index at which
+   * to start changing the array. Items will be removed or added starting from this index.
+   * @param {number} deleteCount - The `deleteCount` parameter in the `splice` method represents the
+   * number of elements to remove from the array starting at the specified `start` index. If
+   * `deleteCount` is not provided, it defaults to the number of elements from the `start` index to the
+   * end of the array (`
+   * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+   * will be inserted into the deque at the specified `start` index. These elements will be inserted in
+   * place of the elements that are removed based on the `start` and `deleteCount` parameters.
+   * @returns The `splice` method is returning the array `deletedElements` which contains the elements
+   * that were removed from the Deque during the splice operation.
+   */
+  splice(start, deleteCount = this._length - start, ...items) {
+    rangeCheck(start, 0, this._length);
+    if (deleteCount < 0) deleteCount = 0;
+    if (start + deleteCount > this._length) deleteCount = this._length - start;
+    const deletedElements = this._createInstance();
+    for (let i = 0; i < deleteCount; i++) {
+      deletedElements.push(this.at(start + i));
+    }
+    const elementsAfter = [];
+    for (let i = start + deleteCount; i < this._length; i++) {
+      elementsAfter.push(this.at(i));
+    }
+    this.cut(start - 1, true);
+    for (const item of items) {
+      this.push(item);
+    }
+    for (const element of elementsAfter) {
+      this.push(element);
+    }
+    return deletedElements;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1) or O(n)
+   *
+   * The `cutRest` function cuts the elements from a specified position in a deque and returns a new
+   * deque with the cut elements.
+   * @param {number} pos - The `pos` parameter represents the position from which to cut the Deque. It
+   * is a number that indicates the index of the element in the Deque where the cut should start.
+   * @param [isCutSelf=false] - isCutSelf is a boolean parameter that determines whether the original
+   * Deque should be modified or a new Deque should be created. If isCutSelf is true, the original
+   * Deque will be modified by cutting off elements starting from the specified position. If isCutSelf
+   * is false, a new De
+   * @returns The function `cutRest` returns either the modified original deque (`this`) or a new deque
+   * (`newDeque`) depending on the value of the `isCutSelf` parameter.
+   */
+  cutRest(pos, isCutSelf = false) {
+    if (isCutSelf) {
+      if (pos < 0) {
+        return this;
+      }
+      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+      this._bucketFirst = bucketIndex;
+      this._firstInBucket = indexInBucket;
+      this._length = this._length - pos;
+      return this;
+    } else {
+      const newDeque = this._createInstance({
+        bucketSize: this._bucketSize,
+        toElementFn: this._toElementFn,
+        maxLen: this._maxLen
+      });
+      if (pos < 0) pos = 0;
+      for (let i = pos; i < this._length; i++) {
+        newDeque.push(this.at(i));
+      }
+      return newDeque;
+    }
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1) or O(n)
+   *
+   * The `deleteAt` function removes an element at a specified position in an array-like data
+   * structure.
+   * @param {number} pos - The `pos` parameter in the `deleteAt` function represents the position at
+   * which an element needs to be deleted from the data structure. It is of type `number` and indicates
+   * the index of the element to be deleted.
+   * @returns The size of the data structure after the deletion operation is performed.
+   */
+  deleteAt(pos) {
+    rangeCheck(pos, 0, this._length - 1);
+    let deleted;
+    if (pos === 0) {
+      return this.shift();
+    } else if (pos === this._length - 1) {
+      deleted = this.last;
+      this.pop();
+      return deleted;
+    } else {
+      const length = this._length - 1;
+      const { bucketIndex: targetBucket, indexInBucket: targetPointer } = this._getBucketAndPosition(pos);
+      deleted = this._buckets[targetBucket][targetPointer];
+      for (let i = pos; i < length; i++) {
+        const { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(i);
+        const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(i + 1);
+        this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
+      }
+      this.pop();
+      return deleted;
+    }
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `delete` function removes all occurrences of a specified element from an array-like data
+   * structure.
+   * @param {E} element - The `element` parameter represents the element that you want to delete from
+   * the data structure.
+   * @returns The size of the data structure after the element has been deleted.
+   */
+  delete(element) {
+    const size = this._length;
+    if (size === 0) return false;
+    let i = 0;
+    let index = 0;
+    while (i < size) {
+      const oldElement = this.at(i);
+      if (oldElement !== element) {
+        this.setAt(index, oldElement);
+        index += 1;
+      }
+      i += 1;
+    }
+    this.cut(index - 1, true);
+    return true;
+  }
+  // /**
+  //  * Time Complexity: O(n)
+  //  * Space Complexity: O(1)
+  //  *
+  //  * This function overrides the indexOf method to search for an element within a custom data
+  //  * structure.
+  //  * @param {E} searchElement - The `searchElement` parameter is the element that you are searching for
+  //  * within the data structure. The `indexOf` method will return the index of the first occurrence of
+  //  * this element within the data structure.
+  //  * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` method specifies the
+  //  * index at which to start searching for the `searchElement` within the data structure. If provided,
+  //  * the search will begin at this index instead of the beginning of the data structure.
+  //  * @returns The indexOf method is returning the index of the searchElement if it is found in the data
+  //  * structure, or -1 if the searchElement is not found.
+  //  */
+  // override indexOf(searchElement: E, fromIndex: number = 0): number {
+  //   let index = fromIndex;
+  //   let bucketIndex = this._bucketFirst;
+  //   let indexInBucket = this._firstInBucket + fromIndex;
+  //
+  //   for (let i = 0; i < this._length; i++) {
+  //     if (this._buckets[bucketIndex][indexInBucket] === searchElement) {
+  //       return index;
+  //     }
+  //     index++;
+  //     indexInBucket++;
+  //     if (indexInBucket >= this._bucketSize) {
+  //       bucketIndex++;
+  //       indexInBucket = 0;
+  //     }
+  //     if (bucketIndex >= this._bucketCount) {
+  //       bucketIndex = 0;
+  //     }
+  //   }
+  //   return -1;
+  // }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The reverse() function reverses the order of the buckets and the elements within each bucket in a
+   * data structure.
+   * @returns The reverse() method is returning the object itself (this) after performing the reverse
+   * operation on the buckets and updating the relevant properties.
+   */
+  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;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `unique()` function removes duplicate elements from an array-like data structure and returns
+   * the number of unique elements.
+   * @returns The size of the modified array is being returned.
+   */
+  unique() {
+    if (this._length <= 1) {
+      return this;
+    }
+    let index = 1;
+    let prev = this.at(0);
+    for (let i = 1; i < this._length; ++i) {
+      const cur = this.at(i);
+      if (cur !== prev) {
+        prev = cur;
+        this.setAt(index++, cur);
+      }
+    }
+    this.cut(index - 1, true);
+    return this;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `shrinkToFit` function reorganizes the elements in an array-like data structure to minimize
+   * memory usage.
+   * @returns Nothing is being returned. The function is using the `return` statement to exit early if
+   * `this._length` is 0, but it does not return any value.
+   */
+  shrinkToFit() {
+    if (this._length === 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;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `clone()` function returns a new instance of the `Deque` class with the same elements and
+   * bucket size as the original instance.
+   * @returns The `clone()` method is returning a new instance of the `Deque` class with the same
+   * elements as the original deque (`this`) and the same bucket size.
+   */
+  clone() {
+    return new _Deque(this, {
+      bucketSize: this.bucketSize,
+      toElementFn: this.toElementFn,
+      maxLen: this._maxLen
+    });
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function creates a new deque containing elements from the original deque that satisfy
+   * a given predicate function.
+   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+   * the current element being iterated over, the index of the current element, and the deque itself.
+   * It should return a boolean value indicating whether the element should be included in the filtered
+   * deque or not.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+   * passed as the `this` value to the `predicate` function. If `thisArg` is
+   * @returns The `filter` method is returning a new `Deque` object that contains the elements that
+   * satisfy the given predicate function.
+   */
+  filter(predicate, thisArg) {
+    const newDeque = this._createInstance({
+      bucketSize: this._bucketSize,
+      toElementFn: this.toElementFn,
+      maxLen: this._maxLen
+    });
+    let index = 0;
+    for (const el of this) {
+      if (predicate.call(thisArg, el, index, this)) {
+        newDeque.push(el);
+      }
+      index++;
+    }
+    return newDeque;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function takes a callback function and applies it to each element in the deque,
+   * returning a new deque with the results.
+   * @param callback - The callback parameter is a function that will be called for each element in the
+   * deque. It takes three arguments: the current element, the index of the element, and the deque
+   * itself. It should return a value of type EM.
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+   * transform the raw element (`RM`) into a new element (`EM`) before adding it to the new deque. If
+   * provided, this function will be called for each raw element in the original deque.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the callback function. It is used to set the context or scope
+   * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+   * value of
+   * @returns a new Deque object with elements of type EM and raw elements of type RM.
+   */
+  map(callback, toElementFn, thisArg) {
+    const newDeque = new _Deque([], { bucketSize: this._bucketSize, toElementFn, maxLen: this._maxLen });
+    let index = 0;
+    for (const el of this) {
+      newDeque.push(callback.call(thisArg, el, index, this));
+      index++;
+    }
+    return newDeque;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The above function is an implementation of the iterator protocol in TypeScript, allowing the
+   * object to be iterated over using a for...of loop.
+   */
+  *_getIterator() {
+    for (let i = 0; i < this._length; ++i) {
+      yield this.at(i);
+    }
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `_reallocate` function reallocates the buckets in an array, adding new buckets if needed.
+   * @param {number} [needBucketNum] - The `needBucketNum` parameter is an optional number that
+   * specifies the number of new buckets needed. If not provided, it will default to half of the
+   * current bucket count (`this._bucketCount >> 1`) or 1 if the current bucket count is less than 2.
+   */
+  _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;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function calculates the bucket index and index within the bucket based on the given position.
+   * @param {number} pos - The `pos` parameter represents the position within the data structure. It is
+   * a number that indicates the index or position of an element within the structure.
+   * @returns an object with two properties: "bucketIndex" and "indexInBucket".
+   */
+  _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 };
+  }
+  /**
+   * The function `_createInstance` returns a new instance of the `Deque` class with the specified
+   * options.
+   * @param [options] - The `options` parameter in the `_createInstance` method is of type
+   * `DequeOptions<E, R>`, which is an optional parameter that allows you to pass additional
+   * configuration options when creating a new instance of the `Deque` class.
+   * @returns An instance of the `Deque` class with an empty array and the provided options, casted as
+   * `this`.
+   */
+  _createInstance(options) {
+    return new _Deque([], options);
+  }
+  /**
+   * This function returns an iterator that iterates over elements in reverse order.
+   */
+  *_getReverseIterator() {
+    for (let i = this._length - 1; i > -1; i--) {
+      yield this.at(i);
+    }
+  }
+};
+export {
+  Deque
+};
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */