data-structure-typed 2.0.1 → 2.0.3

package/dist/individuals/linked-list/doubly-linked-list.mjs

@@ -1,1495 +0,0 @@
-// 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 LinkedListNode = class {
-  constructor(value) {
-    this._value = value;
-    this._next = void 0;
-  }
-  _value;
-  get value() {
-    return this._value;
-  }
-  set value(value) {
-    this._value = value;
-  }
-  _next;
-  get next() {
-    return this._next;
-  }
-  set next(value) {
-    this._next = value;
-  }
-};
-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;
-  }
-};
-var LinearLinkedBase = class extends LinearBase {
-  /**
-   * The constructor initializes the LinearBase class with optional options, setting the maximum length
-   * if provided and valid.
-   * @param [options] - The `options` parameter is an optional object that can be passed to the
-   * constructor. It is of type `LinearBaseOptions<E, R>`. This object may contain properties such as
-   * `maxLen`, which is a number representing the maximum length. If `maxLen` is a positive integer,
-   */
-  constructor(options) {
-    super(options);
-    if (options) {
-      const { maxLen } = options;
-      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function overrides the indexOf method to improve performance by searching for an element in a
-   * custom array implementation starting from a specified index.
-   * @param {E} searchElement - The `searchElement` parameter is the element that you are searching for
-   * within the array. The `indexOf` method will return the index of the first occurrence of this
-   * element within the array.
-   * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` method specifies the
-   * index in the array at which to start the search for the `searchElement`. If provided, the search
-   * will begin at the specified index and continue to the end of the array. If not provided, the
-   * search will start at index
-   * @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) {
-    const iterator = this._getIterator();
-    let current = iterator.next();
-    let index = 0;
-    while (index < fromIndex) {
-      current = iterator.next();
-      index++;
-    }
-    while (!current.done) {
-      if (current.value === searchElement) return index;
-      current = iterator.next();
-      index++;
-    }
-    return -1;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function overrides the lastIndexOf method in TypeScript to improve performance by searching
-   * for an element in reverse order starting from a specified index.
-   * @param {E} searchElement - The `searchElement` parameter is the element that you want to find
-   * within the array. The `lastIndexOf` method searches the array for this element starting from the
-   * end of the array (or from the specified `fromIndex` if provided) and returns the index of the last
-   * occurrence of the element
-   * @param {number} fromIndex - The `fromIndex` parameter in the `lastIndexOf` method specifies the
-   * index at which to start searching for the `searchElement` in the array. If provided, the search
-   * will begin at this index and move towards the beginning of the array. If not provided, the search
-   * will start at the
-   * @returns The `lastIndexOf` method is being overridden to search for the `searchElement` starting
-   * from the specified `fromIndex` (defaulting to the end of the array). It iterates over the array in
-   * reverse order using a custom iterator `_getReverseIterator` and returns the index of the last
-   * occurrence of the `searchElement` if found, or -1 if not found.
-   */
-  lastIndexOf(searchElement, fromIndex = this.length - 1) {
-    const iterator = this._getReverseIterator();
-    let current = iterator.next();
-    let index = this.length - 1;
-    while (index > fromIndex) {
-      current = iterator.next();
-      index--;
-    }
-    while (!current.done) {
-      if (current.value === searchElement) return index;
-      current = iterator.next();
-      index--;
-    }
-    return -1;
-  }
-  /**
-   * Time Complexity: O(n + m)
-   * Space Complexity: O(n + m)
-   *
-   * The `concat` function in TypeScript overrides the default behavior to concatenate items into a new
-   * list, handling both individual elements and instances of `LinearBase`.
-   * @param {(E | LinearBase<E, R>)[]} items - The `concat` method you provided takes in a variable
-   * number of arguments of type `E` or `LinearBase<E, R>`. The method concatenates these items to the
-   * current list and returns a new list with the concatenated items.
-   * @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(m)
-   * Space Complexity: O(m)
-   *
-   * The `slice` method is overridden to improve performance by creating a new instance and iterating
-   * through the array to extract a subset based on the specified start and end indices.
-   * @param {number} [start=0] - The `start` parameter in the `slice` method specifies the index at
-   * which to begin extracting elements from the array. If no `start` parameter is provided, the
-   * default value is 0, indicating that extraction should 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 of the array. If not provided, it defaults to the length of the array.
-   * @returns The `slice` method is returning a new instance of the array implementation with elements
-   * sliced from the original array based on the `start` and `end` parameters.
-   */
-  slice(start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    const newList = this._createInstance();
-    const iterator = this._getIterator();
-    let current = iterator.next();
-    let c = 0;
-    while (c < start) {
-      current = iterator.next();
-      c++;
-    }
-    for (let i = start; i < end; i++) {
-      newList.push(current.value);
-      current = iterator.next();
-    }
-    return newList;
-  }
-  /**
-   * Time Complexity: O(n + m)
-   * Space Complexity: O(m)
-   *
-   * The function overrides the splice method to handle deletion and insertion of elements in a data
-   * structure while returning the removed elements.
-   * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
-   * to start modifying 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, it defaults to 0, meaning no elements will be removed but new
-   * elements can still be inserted at
-   * @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 there can be multiple elements passed as arguments to be inserted into the array.
-   * @returns The `splice` method is returning a new instance of the data structure that was modified
-   * by removing elements specified by the `start` and `deleteCount` parameters, and inserting new
-   * elements provided in the `items` array.
-   */
-  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, deleteCount);
-    let currentIndex = 0;
-    let currentNode = void 0;
-    let previousNode = void 0;
-    const iterator = this._getNodeIterator();
-    for (const node of iterator) {
-      if (currentIndex === start) {
-        currentNode = node;
-        break;
-      }
-      previousNode = node;
-      currentIndex++;
-    }
-    for (let i = 0; i < deleteCount && currentNode; i++) {
-      removedList.push(currentNode.value);
-      const nextNode = currentNode.next;
-      this.delete(currentNode);
-      currentNode = nextNode;
-    }
-    for (let i = 0; i < items.length; i++) {
-      if (previousNode) {
-        this.addAfter(previousNode, items[i]);
-        previousNode = previousNode.next;
-      } else {
-        this.addAt(0, items[i]);
-        previousNode = this._getNodeIterator().next().value;
-      }
-    }
-    return removedList;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `reduceRight` iterates over an array in reverse order and applies a callback function
-   * to each element, accumulating a single result.
-   * @param callbackfn - The `callbackfn` parameter is a function that will be called on each element
-   * of the array from right to left. It takes four arguments:
-   * @param {U} [initialValue] - The `initialValue` parameter is an optional value that is used as the
-   * initial accumulator value in the reduce operation. If provided, the reduce operation starts with
-   * this initial value and iterates over the elements of the array, applying the callback function to
-   * each element and the current accumulator value. If `initial
-   * @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;
-    let index = this.length - 1;
-    for (const item of this._getReverseIterator()) {
-      accumulator = callbackfn(accumulator, item, index--, this);
-    }
-    return accumulator;
-  }
-};
-
-// src/data-structures/linked-list/doubly-linked-list.ts
-var DoublyLinkedListNode = class extends LinkedListNode {
-  /**
-   * The constructor function initializes the value, next, and previous properties of an object.
-   * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
-   * is defined as a generic type "E".
-   */
-  constructor(value) {
-    super(value);
-    this._value = value;
-    this._next = void 0;
-    this._prev = void 0;
-  }
-  _next;
-  get next() {
-    return this._next;
-  }
-  set next(value) {
-    this._next = value;
-  }
-  _prev;
-  get prev() {
-    return this._prev;
-  }
-  set prev(value) {
-    this._prev = value;
-  }
-};
-var DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
-  /**
-   * This TypeScript constructor initializes a DoublyLinkedList with optional elements and options.
-   * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the constructor is an
-   * iterable collection of elements of type `E` or `R`. It is used to initialize the DoublyLinkedList
-   * with the elements provided in the iterable. If no elements are provided, the default value is an
-   * empty iterable.
-   * @param [options] - The `options` parameter in the constructor is of type
-   * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
-   * configuration options to customize the behavior of the DoublyLinkedList.
-   */
-  constructor(elements = [], options) {
-    super(options);
-    this._head = void 0;
-    this._tail = void 0;
-    this._length = 0;
-    if (options) {
-      const { maxLen } = options;
-      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
-    }
-    this.pushMany(elements);
-  }
-  _head;
-  get head() {
-    return this._head;
-  }
-  _tail;
-  get tail() {
-    return this._tail;
-  }
-  _length;
-  get length() {
-    return this._length;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
-   * @returns The method `get first()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
-   */
-  get first() {
-    return this.head?.value;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
-   * @returns The method `get last()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
-   */
-  get last() {
-    return this.tail?.value;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
-   * given array.
-   * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-   * @returns The `fromArray` function returns a DoublyLinkedList object.
-   */
-  static fromArray(data) {
-    return new _DoublyLinkedList(data);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `isNode` in TypeScript checks if a given input is an instance of
-   * `DoublyLinkedListNode`.
-   * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `isNode` function can
-   * be one of the following types:
-   * @returns The `isNode` function is checking if the `elementNodeOrPredicate` parameter is an
-   * instance of `DoublyLinkedListNode<E>`. If it is, the function returns `true`, indicating that the
-   * parameter is a `DoublyLinkedListNode<E>`. If it is not an instance of `DoublyLinkedListNode<E>`,
-   * the function returns `false`.
-   */
-  isNode(elementNodeOrPredicate) {
-    return elementNodeOrPredicate instanceof DoublyLinkedListNode;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `push` function adds a new element or node to the end of a doubly linked list.
-   * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the `push`
-   * method can accept either an element of type `E` or a `DoublyLinkedListNode<E>` object.
-   * @returns The `push` method is returning a boolean value, specifically `true`.
-   */
-  push(elementOrNode) {
-    const newNode = this._ensureNode(elementOrNode);
-    if (!this.head) {
-      this._head = newNode;
-      this._tail = newNode;
-    } else {
-      newNode.prev = this.tail;
-      this.tail.next = newNode;
-      this._tail = newNode;
-    }
-    this._length++;
-    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 value of the last element in a linked list.
-   * @returns The method is returning the value of the removed node.
-   */
-  pop() {
-    if (!this.tail) return void 0;
-    const removedNode = this.tail;
-    if (this.head === this.tail) {
-      this._head = void 0;
-      this._tail = void 0;
-    } else {
-      this._tail = removedNode.prev;
-      this.tail.next = void 0;
-    }
-    this._length--;
-    return removedNode.value;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `shift()` function removes and returns the value of the first element in a doubly linked list.
-   * @returns The value of the removed node.
-   */
-  shift() {
-    if (!this.head) return void 0;
-    const removedNode = this.head;
-    if (this.head === this.tail) {
-      this._head = void 0;
-      this._tail = void 0;
-    } else {
-      this._head = removedNode.next;
-      this.head.prev = void 0;
-    }
-    this._length--;
-    return removedNode.value;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The unshift function adds a new element or node to the beginning of a doubly linked list.
-   * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
-   * `unshift` method can be either an element of type `E` or a `DoublyLinkedListNode` containing an
-   * element of type `E`.
-   * @returns The `unshift` method is returning a boolean value, specifically `true`.
-   */
-  unshift(elementOrNode) {
-    const newNode = this._ensureNode(elementOrNode);
-    if (!this.head) {
-      this._head = newNode;
-      this._tail = newNode;
-    } else {
-      newNode.next = this.head;
-      this.head.prev = newNode;
-      this._head = newNode;
-    }
-    this._length++;
-    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 a data structure, applying a
-   * transformation function if provided.
-   * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
-   * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
-   * or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and pushes
-   * it onto the linked list. If a transformation function `to
-   * @returns The `pushMany` function is returning an array of boolean values (`ans`) which indicate
-   * the success or failure of pushing each element into the data structure.
-   */
-  pushMany(elements) {
-    const ans = [];
-    for (const el of elements) {
-      if (this.toElementFn) {
-        ans.push(this.push(this.toElementFn(el)));
-        continue;
-      }
-      ans.push(this.push(el));
-    }
-    return ans;
-  }
-  /**
-   * Time Complexity: O(k)
-   * Space Complexity: O(k)
-   *
-   * The function `unshiftMany` iterates through a collection of elements and adds them to the
-   * beginning of a Doubly Linked List, returning an array of boolean values indicating the success of
-   * each insertion.
-   * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
-   * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
-   * `R`, or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and
-   * performs an `unshift` operation on the doubly linked list
-   * @returns The `unshiftMany` function returns an array of boolean values indicating the success of
-   * each unshift operation performed on the elements passed as input.
-   */
-  unshiftMany(elements) {
-    const ans = [];
-    for (const el of elements) {
-      if (this.toElementFn) {
-        ans.push(this.unshift(this.toElementFn(el)));
-        continue;
-      }
-      ans.push(this.unshift(el));
-    }
-    return ans;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `at` function returns the value at a specified index in a linked list, or undefined if the index is out of bounds.
-   * @param {number} index - The index parameter is a number that represents the position of the element we want to
-   * retrieve from the list.
-   * @returns The method is returning the value at the specified index in the linked list. If the index is out of bounds
-   * or the linked list is empty, it will return undefined.
-   */
-  at(index) {
-    if (index < 0 || index >= this._length) return void 0;
-    let current = this.head;
-    for (let i = 0; i < index; i++) {
-      current = current.next;
-    }
-    return current.value;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `getNodeAt` returns the node at a given index in a doubly linked list, or undefined if the index is out of
-   * range.
-   * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
-   * retrieve from the doubly linked list. It indicates the zero-based index of the node we want to access.
-   * @returns The method `getNodeAt(index: number)` returns a `DoublyLinkedListNode<E>` object if the index is within the
-   * valid range of the linked list, otherwise it returns `undefined`.
-   */
-  getNodeAt(index) {
-    if (index < 0 || index >= this._length) return void 0;
-    let current = this.head;
-    for (let i = 0; i < index; i++) {
-      current = current.next;
-    }
-    return current;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * This TypeScript function searches for a node in a doubly linked list based on a given element node
-   * or predicate.
-   * @param {| E
-   *       | DoublyLinkedListNode<E>
-   *       | ((node: DoublyLinkedListNode<E>) => boolean)
-   *       | undefined} elementNodeOrPredicate - The `getNode` method you provided is used to find a
-   * node in a doubly linked list based on a given element, node, or predicate function. The
-   * `elementNodeOrPredicate` parameter can be one of the following:
-   * @returns The `getNode` method returns a `DoublyLinkedListNode<E>` or `undefined` based on the
-   * input `elementNodeOrPredicate`. If the input is `undefined`, the method returns `undefined`.
-   * Otherwise, it iterates through the linked list starting from the head node and applies the
-   * provided predicate function to each node. If a node satisfies the predicate, that node is
-   * returned. If
-   */
-  getNode(elementNodeOrPredicate) {
-    if (elementNodeOrPredicate === void 0) return;
-    if (this.isNode(elementNodeOrPredicate)) return elementNodeOrPredicate;
-    const predicate = this._ensurePredicate(elementNodeOrPredicate);
-    let current = this.head;
-    while (current) {
-      if (predicate(current)) {
-        return current;
-      }
-      current = current.next;
-    }
-    return void 0;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `addAt` function inserts a new element or node at a specified index in a doubly linked list.
-   * @param {number} index - The `index` parameter in the `addAt` method represents the position at
-   * which you want to add a new element or node in the doubly linked list. It indicates the location
-   * where the new element or node should be inserted.
-   * @param {E | DoublyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
-   * `addAt` method can be either a value of type `E` or a `DoublyLinkedListNode<E>` object.
-   * @returns The `addAt` method returns a boolean value. It returns `true` if the element or node was
-   * successfully added at the specified index, and `false` if the index is out of bounds (less than 0
-   * or greater than the length of the list).
-   */
-  addAt(index, newElementOrNode) {
-    if (index < 0 || index > this._length) return false;
-    if (index === 0) {
-      this.unshift(newElementOrNode);
-      return true;
-    }
-    if (index === this._length) {
-      this.push(newElementOrNode);
-      return true;
-    }
-    const newNode = this._ensureNode(newElementOrNode);
-    const prevNode = this.getNodeAt(index - 1);
-    const nextNode = prevNode.next;
-    newNode.prev = prevNode;
-    newNode.next = nextNode;
-    prevNode.next = newNode;
-    nextNode.prev = newNode;
-    this._length++;
-    return true;
-  }
-  /**
-   * Time Complexity: O(1) or O(n)
-   * Space Complexity: O(1)
-   *
-   * The `addBefore` function in TypeScript adds a new element or node before an existing element or
-   * node in a doubly linked list.
-   * @param {E | DoublyLinkedListNode<E>} existingElementOrNode - The `existingElementOrNode` parameter
-   * in the `addBefore` method can be either an element of type `E` or a `DoublyLinkedListNode<E>`.
-   * @param {E | DoublyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter
-   * represents the element or node that you want to add before the `existingElementOrNode` in a doubly
-   * linked list.
-   * @returns The `addBefore` method returns a boolean value - `true` if the new element or node was
-   * successfully added before the existing element or node, and `false` if the existing element or
-   * node was not found.
-   */
-  addBefore(existingElementOrNode, newElementOrNode) {
-    const existingNode = this.isNode(existingElementOrNode) ? existingElementOrNode : this.getNode(existingElementOrNode);
-    if (existingNode) {
-      const newNode = this._ensureNode(newElementOrNode);
-      newNode.prev = existingNode.prev;
-      if (existingNode.prev) {
-        existingNode.prev.next = newNode;
-      }
-      newNode.next = existingNode;
-      existingNode.prev = newNode;
-      if (existingNode === this.head) {
-        this._head = newNode;
-      }
-      this._length++;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(1) or O(n)
-   * Space Complexity: O(1)
-   *
-   * The `addAfter` function in TypeScript adds a new element or node after an existing element or node
-   * in a doubly linked list.
-   * @param {E | DoublyLinkedListNode<E>} existingElementOrNode - existingElementOrNode represents the
-   * element or node in the doubly linked list after which you want to add a new element or node.
-   * @param {E | DoublyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
-   * `addAfter` method represents the element or node that you want to add after the existing element
-   * or node in a doubly linked list. This parameter can be either an element value or a
-   * `DoublyLinkedListNode` object that you want to insert
-   * @returns The `addAfter` method returns a boolean value - `true` if the new element or node was
-   * successfully added after the existing element or node, and `false` if the existing element or node
-   * was not found in the linked list.
-   */
-  addAfter(existingElementOrNode, newElementOrNode) {
-    const existingNode = this.isNode(existingElementOrNode) ? existingElementOrNode : this.getNode(existingElementOrNode);
-    if (existingNode) {
-      const newNode = this._ensureNode(newElementOrNode);
-      newNode.next = existingNode.next;
-      if (existingNode.next) {
-        existingNode.next.prev = newNode;
-      }
-      newNode.prev = existingNode;
-      existingNode.next = newNode;
-      if (existingNode === this.tail) {
-        this._tail = newNode;
-      }
-      this._length++;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `setAt` updates the value at a specified index in a data structure if the index
-   * exists.
-   * @param {number} index - The `index` parameter in the `setAt` method refers to the position in the
-   * data structure where you want to set a new value.
-   * @param {E} value - The `value` parameter in the `setAt` method represents the new value that you
-   * want to set at the specified index in the data structure.
-   * @returns The `setAt` method returns a boolean value - `true` if the value at the specified index
-   * is successfully updated, and `false` if the index is out of bounds.
-   */
-  setAt(index, value) {
-    const node = this.getNodeAt(index);
-    if (node) {
-      node.value = value;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
-   * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
-   * data structure. It is of type number.
-   * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
-   * bounds.
-   */
-  deleteAt(index) {
-    if (index < 0 || index >= this._length) return;
-    let deleted;
-    if (index === 0) {
-      deleted = this.first;
-      this.shift();
-      return deleted;
-    }
-    if (index === this._length - 1) {
-      deleted = this.last;
-      this.pop();
-      return deleted;
-    }
-    const removedNode = this.getNodeAt(index);
-    const prevNode = removedNode.prev;
-    const nextNode = removedNode.next;
-    prevNode.next = nextNode;
-    nextNode.prev = prevNode;
-    this._length--;
-    return removedNode?.value;
-  }
-  /**
-   * Time Complexity: O(1) or O(n)
-   * Space Complexity: O(1)
-   *
-   * The `delete` function removes a specified element or node from a doubly linked list if it exists.
-   * @param {E | DoublyLinkedListNode<E> | undefined} elementOrNode - The `elementOrNode` parameter in
-   * the `delete` method can accept an element of type `E`, a `DoublyLinkedListNode` of type `E`, or it
-   * can be `undefined`. This parameter is used to identify the node that needs to be deleted from the
-   * doubly linked list
-   * @returns The `delete` method returns a boolean value - `true` if the element or node was
-   * successfully deleted from the doubly linked list, and `false` if the element or node was not found
-   * in the list.
-   */
-  delete(elementOrNode) {
-    const node = this.getNode(elementOrNode);
-    if (node) {
-      if (node === this.head) {
-        this.shift();
-      } else if (node === this.tail) {
-        this.pop();
-      } else {
-        const prevNode = node.prev;
-        const nextNode = node.next;
-        if (prevNode) prevNode.next = nextNode;
-        if (nextNode) nextNode.prev = prevNode;
-        this._length--;
-      }
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a variable has a length greater than zero and returns a boolean value.
-   * @returns A boolean value is being returned.
-   */
-  isEmpty() {
-    return this._length === 0;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
-   */
-  clear() {
-    this._head = void 0;
-    this._tail = void 0;
-    this._length = 0;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * This function retrieves an element from a doubly linked list based on a given element
-   * node or predicate.
-   * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `get` method takes in a parameter called `elementNodeOrPredicate`,
-   * which can be one of the following types:
-   * @returns The `get` method returns the value of the first node in the doubly linked list that
-   * satisfies the provided predicate function. If no such node is found, it returns `undefined`.
-   */
-  search(elementNodeOrPredicate) {
-    const predicate = this._ensurePredicate(elementNodeOrPredicate);
-    let current = this.head;
-    while (current) {
-      if (predicate(current)) return current.value;
-      current = current.next;
-    }
-    return void 0;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `getBackward` function searches for a specific element in a doubly linked list starting from
-   * the tail and moving backwards.
-   * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `getBackward`
-   * function can be one of the following types:
-   * @returns The `getBackward` method returns the value of the element node that matches the provided
-   * predicate when traversing the doubly linked list backwards. If no matching element is found, it
-   * returns `undefined`.
-   */
-  getBackward(elementNodeOrPredicate) {
-    const predicate = this._ensurePredicate(elementNodeOrPredicate);
-    let current = this.tail;
-    while (current) {
-      if (predicate(current)) return current.value;
-      current = current.prev;
-    }
-    return void 0;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `reverse` function reverses the order of the elements in a doubly linked list.
-   */
-  reverse() {
-    let current = this.head;
-    [this._head, this._tail] = [this.tail, this.head];
-    while (current) {
-      const next = current.next;
-      [current.prev, current.next] = [current.next, current.prev];
-      current = next;
-    }
-    return this;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `clone` function creates a new instance of the `DoublyLinkedList` class with the same values
-   * as the original list.
-   * @returns The `clone()` method is returning a new instance of the `DoublyLinkedList` class, which
-   * is a copy of the original list.
-   */
-  clone() {
-    return new _DoublyLinkedList(this, { toElementFn: this._toElementFn, maxLen: this._maxLen });
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `filter` function creates a new DoublyLinkedList by iterating over the elements of the current
-   * list and applying a callback function to each element, returning only the elements for which the
-   * callback function returns true.
-   * @param callback - The `callback` parameter is a function that will be called for each element in
-   * the DoublyLinkedList. It takes three arguments: the current element, the index of the current
-   * element, and the DoublyLinkedList itself. The callback function should return a boolean value
-   * indicating whether the current element should be included
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-   * passed as the `this` value to the `callback` function. If `thisArg` is
-   * @returns The `filter` method is returning a new `DoublyLinkedList` object that contains the
-   * elements that pass the filter condition specified by the `callback` function.
-   */
-  filter(callback, thisArg) {
-    const filteredList = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
-    let index = 0;
-    for (const current of this) {
-      if (callback.call(thisArg, current, index, this)) {
-        filteredList.push(current);
-      }
-      index++;
-    }
-    return filteredList;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `map` function takes a callback function and returns a new DoublyLinkedList with the results
-   * of applying the callback to each element in the original list.
-   * @param callback - The callback parameter is a function that will be called for each element in the
-   * original DoublyLinkedList. It takes three arguments: current (the current element being
-   * processed), index (the index of the current element), and this (the original DoublyLinkedList).
-   * The callback function should return a value of type
-   * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
-   * convert the raw element (`RR`) to the desired element type (`T`). It takes the raw element as
-   * input and returns the converted element. If this parameter is not provided, the raw element will
-   * be used as is.
-   * @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 instance of the `DoublyLinkedList` class with elements of type `T` and `RR`.
-   */
-  map(callback, toElementFn, thisArg) {
-    const mappedList = new _DoublyLinkedList([], { toElementFn, maxLen: this._maxLen });
-    let index = 0;
-    for (const current of this) {
-      mappedList.push(callback.call(thisArg, current, index, this));
-      index++;
-    }
-    return mappedList;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `countOccurrences` iterates through a doubly linked list and counts the occurrences
-   * of a specified element or nodes that satisfy a given predicate.
-   * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementOrNode
-   * - The `elementOrNode` parameter in the `countOccurrences` method can accept three types of values:
-   * @returns The `countOccurrences` method returns the number of occurrences of the specified element,
-   * node, or predicate function in the doubly linked list.
-   */
-  countOccurrences(elementOrNode) {
-    const predicate = this._ensurePredicate(elementOrNode);
-    let count = 0;
-    let current = this.head;
-    while (current) {
-      if (predicate(current)) {
-        count++;
-      }
-      current = current.next;
-    }
-    return count;
-  }
-  /**
-   * The function returns an iterator that iterates over the values of a linked list.
-   */
-  *_getIterator() {
-    let current = this.head;
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
-  }
-  /**
-   * The function returns an iterator that iterates over the elements of a data structure in reverse
-   * order.
-   */
-  *_getReverseIterator() {
-    let current = this.tail;
-    while (current) {
-      yield current.value;
-      current = current.prev;
-    }
-  }
-  /**
-   * The function returns an iterator that iterates over the nodes of a doubly linked list starting
-   * from the head.
-   */
-  *_getNodeIterator() {
-    let current = this.head;
-    while (current) {
-      yield current;
-      current = current.next;
-    }
-  }
-  // protected *_getReverseNodeIterator(): IterableIterator<DoublyLinkedListNode<E>> {
-  //   const reversedArr = [...this._getNodeIterator()].reverse();
-  //
-  //   for (const item of reversedArr) {
-  //     yield item;
-  //   }
-  // }
-  /**
-   * The function `_isPredicate` checks if the input is a function that takes a `DoublyLinkedListNode`
-   * as an argument and returns a boolean.
-   * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following
-   * types:
-   * @returns The _isPredicate method is returning a boolean value indicating whether the
-   * elementNodeOrPredicate parameter is a function or not. If the elementNodeOrPredicate is a
-   * function, the method will return true, indicating that it is a predicate function.
-   */
-  _isPredicate(elementNodeOrPredicate) {
-    return typeof elementNodeOrPredicate === "function";
-  }
-  /**
-   * The function `_ensureNode` ensures that the input is a valid node in a doubly linked list.
-   * @param {E | DoublyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter can be either
-   * an element of type `E` or a `DoublyLinkedListNode` containing an element of type `E`.
-   * @returns If the `elementOrNode` parameter is already a `DoublyLinkedListNode`, it will be returned
-   * as is. Otherwise, a new `DoublyLinkedListNode` instance will be created with the `elementOrNode`
-   * value and returned.
-   */
-  _ensureNode(elementOrNode) {
-    if (this.isNode(elementOrNode)) return elementOrNode;
-    return new DoublyLinkedListNode(elementOrNode);
-  }
-  /**
-   * The function `_ensurePredicate` in TypeScript ensures that the input is either a node, a predicate
-   * function, or a value to compare with the node's value.
-   * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following
-   * types:
-   * @returns A function is being returned that takes a `DoublyLinkedListNode` as a parameter and
-   * returns a boolean value based on the conditions specified in the code.
-   */
-  _ensurePredicate(elementNodeOrPredicate) {
-    if (this.isNode(elementNodeOrPredicate)) return (node) => node === elementNodeOrPredicate;
-    if (this._isPredicate(elementNodeOrPredicate)) return elementNodeOrPredicate;
-    return (node) => node.value === elementNodeOrPredicate;
-  }
-  /**
-   * The function `_createInstance` returns a new instance of `DoublyLinkedList` with the specified
-   * options.
-   * @param [options] - The `options` parameter in the `_createInstance` method is of type
-   * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
-   * configuration options when creating a new instance of the `DoublyLinkedList` class.
-   * @returns An instance of the `DoublyLinkedList` class with an empty array and the provided options
-   * is being returned, cast as the current class type.
-   */
-  _createInstance(options) {
-    return new _DoublyLinkedList([], options);
-  }
-  /**
-   * The function `_getPrevNode` returns the previous node of a given node in a doubly linked list.
-   * @param node - The parameter `node` in the `_getPrevNode` method is of type
-   * `DoublyLinkedListNode<E>`, which represents a node in a doubly linked list containing an element
-   * of type `E`.
-   * @returns The `_getPrevNode` method is returning the previous node of the input `node` in a doubly
-   * linked list. If the input node has a previous node, it will return that node. Otherwise, it will
-   * return `undefined`.
-   */
-  _getPrevNode(node) {
-    return node.prev;
-  }
-};
-export {
-  DoublyLinkedList,
-  DoublyLinkedListNode
-};
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */