data-structure-typed 2.0.1 → 2.0.2

package/dist/individuals/queue/deque.mjs

@@ -1,1262 +0,0 @@
-// 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
- */