data-structure-typed 2.0.1 → 2.0.2

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

@@ -1,1479 +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/singly-linked-list.ts
-var SinglyLinkedListNode = class extends LinkedListNode {
-  /**
-   * The constructor function initializes an instance of a class with a given value and sets the next property to undefined.
-   * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
-   * will be stored in the node of a linked list.
-   */
-  constructor(value) {
-    super(value);
-    this._value = value;
-    this._next = void 0;
-  }
-  _next;
-  get next() {
-    return this._next;
-  }
-  set next(value) {
-    this._next = value;
-  }
-};
-var SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
-  constructor(elements = [], options) {
-    super(options);
-    if (options) {
-    }
-    this.pushMany(elements);
-  }
-  _head;
-  get head() {
-    return this._head;
-  }
-  _tail;
-  get tail() {
-    return this._tail;
-  }
-  get first() {
-    return this.head?.value;
-  }
-  get last() {
-    return this.tail?.value;
-  }
-  _length = 0;
-  get length() {
-    return this._length;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `fromArray` function creates a new SinglyLinkedList instance 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 `SinglyLinkedList` object.
-   */
-  static fromArray(data) {
-    const singlyLinkedList = new _SinglyLinkedList();
-    for (const item of data) {
-      singlyLinkedList.push(item);
-    }
-    return singlyLinkedList;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `push` function adds a new element or node to the end of a singly linked list.
-   * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the `push`
-   * method can accept either an element of type `E` or a `SinglyLinkedListNode<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 {
-      this.tail.next = newNode;
-      this._tail = newNode;
-    }
-    this._length++;
-    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
-    return true;
-  }
-  /**
-   * Time Complexity: O(n)
-   * 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 element that is being popped from the end of the
-   * list.
-   */
-  pop() {
-    if (!this.head) return void 0;
-    if (this.head === this.tail) {
-      const value2 = this.head.value;
-      this._head = void 0;
-      this._tail = void 0;
-      this._length--;
-      return value2;
-    }
-    let current = this.head;
-    while (current.next !== this.tail) {
-      current = current.next;
-    }
-    const value = this.tail.value;
-    current.next = void 0;
-    this._tail = current;
-    this._length--;
-    return value;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `shift()` function removes and returns the value of the first element in a linked list.
-   * @returns The value of the removed node.
-   */
-  shift() {
-    if (!this.head) return void 0;
-    const removedNode = this.head;
-    this._head = this.head.next;
-    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 singly linked list in
-   * TypeScript.
-   * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter in the
-   * `unshift` method can be either an element of type `E` or a `SinglyLinkedListNode` 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 = newNode;
-    }
-    this._length++;
-    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<SinglyLinkedListNode<E>>} elements - The `elements`
-   * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
-   * or `SinglyLinkedListNode<E>`.
-   * @returns The `pushMany` function returns an array of boolean values indicating whether each
-   * element was successfully pushed 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 over elements and adds them to a data structure, optionally
-   * converting them using a provided function.
-   * @param {Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>} elements - The `elements`
-   * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
-   * `R`, or `SinglyLinkedListNode<E>`. The function iterates over each element in the iterable and
-   * performs an `unshift` operation on the linked list for each
-   * @returns The `unshiftMany` function is returning an array of boolean values, where each value
-   * represents the result of calling the `unshift` method on the current instance of the class.
-   */
-  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)
-   *
-   * This function searches for a specific element in a singly linked list based on a given node or
-   * predicate.
-   * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `get` method can be one of
-   * the following types:
-   * @returns The `get` method returns the value of the first node in the singly 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 function `at` returns the value at a specified index in a 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 element we want to
-   * retrieve from the list.
-   * @returns The method `at(index: number): E | undefined` returns the value at the specified index in the linked list, or
-   * `undefined` if the index is out of bounds.
-   */
-  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(1)
-   * Space Complexity: O(1)
-   *
-   * The function `isNode` in TypeScript checks if the input is an instance of `SinglyLinkedListNode`.
-   * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<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 `SinglyLinkedListNode<E>`. If it is, the function returns `true`, indicating that the
-   * parameter is a `SinglyLinkedListNode<E>`. If it is not an instance of `SinglyLinkedListNode<E>`,
-   * the function returns `false`.
-   */
-  isNode(elementNodeOrPredicate) {
-    return elementNodeOrPredicate instanceof SinglyLinkedListNode;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `getNodeAt` returns the node at a given index in a singly linked list.
-   * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
-   * retrieve from the linked list. It indicates the zero-based index of the node we want to access.
-   * @returns The method `getNodeAt(index: number)` returns a `SinglyLinkedListNode<E>` object if the node at the
-   * specified index exists, or `undefined` if the index is out of bounds.
-   */
-  getNodeAt(index) {
-    let current = this.head;
-    for (let i = 0; i < index; i++) {
-      current = current.next;
-    }
-    return current;
-  }
-  /**
-   * 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;
-    }
-    const targetNode = this.getNodeAt(index);
-    const prevNode = this._getPrevNode(targetNode);
-    if (prevNode && targetNode) {
-      deleted = targetNode.value;
-      prevNode.next = targetNode.next;
-      if (targetNode === this.tail) this._tail = prevNode;
-      this._length--;
-      return deleted;
-    }
-    return;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The delete function removes a node with a specific value from a singly linked list.
-   * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter can accept either a value of type `E`
-   * or a `SinglyLinkedListNode<E>` object.
-   * @returns The `delete` method returns a boolean value. It returns `true` if the value or node is found and
-   * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
-   */
-  delete(elementOrNode) {
-    if (elementOrNode === void 0 || !this.head) return false;
-    const node = this.isNode(elementOrNode) ? elementOrNode : this.getNode(elementOrNode);
-    if (!node) return false;
-    const prevNode = this._getPrevNode(node);
-    if (!prevNode) {
-      this._head = node.next;
-      if (node === this.tail) this._tail = void 0;
-    } else {
-      prevNode.next = node.next;
-      if (node === this.tail) this._tail = prevNode;
-    }
-    this._length--;
-    return true;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `addAt` function inserts a new element or node at a specified index in a singly linked list.
-   * @param {number} index - The `index` parameter represents the position at which you want to add a
-   * new element or node in the linked list. It is a number that indicates the index where the new
-   * element or node should be inserted.
-   * @param {E | SinglyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
-   * `addAt` method can be either a value of type `E` or a `SinglyLinkedListNode<E>` object. This
-   * parameter represents the element or node that you want to add to the linked list at the specified
-   * index.
-   * @returns The `addAt` method returns a boolean value - `true` if the element or node was
-   * successfully added at the specified index, and `false` if the index is out of bounds.
-   */
-  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);
-    newNode.next = prevNode.next;
-    prevNode.next = newNode;
-    this._length++;
-    return true;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function setAt(index, value) 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 (i.e., the node at that index
-   * does not exist).
-   */
-  setAt(index, value) {
-    const node = this.getNodeAt(index);
-    if (node) {
-      node.value = value;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if the length of a data structure is equal to zero and returns a boolean value indicating
-   * whether it is empty or not.
-   * @returns A boolean value indicating whether the length of the object is equal to 0.
-   */
-  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)
-   *
-   * The `reverse` function reverses the order of the nodes in a singly linked list.
-   * @returns The reverse() method does not return anything. It has a return type of void.
-   */
-  reverse() {
-    if (!this.head || this.head === this.tail) return this;
-    let prev = void 0;
-    let current = this.head;
-    let next = void 0;
-    while (current) {
-      next = current.next;
-      current.next = prev;
-      prev = current;
-      current = next;
-    }
-    [this._head, this._tail] = [this.tail, this.head];
-    return this;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `getNode` in TypeScript searches for a node in a singly linked list based on a given
-   * element, node, or predicate.
-   * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean) | undefined} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `getNode` method can be one
-   * of the following types:
-   * @returns The `getNode` method returns either a `SinglyLinkedListNode<E>` if a matching node is
-   * found based on the provided predicate, or it returns `undefined` if no matching node is found or
-   * if the input parameter is `undefined`.
-   */
-  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 function `addBefore` in TypeScript adds a new element or node before an existing element or
-   * node in a singly linked list.
-   * @param {E | SinglyLinkedListNode<E>} existingElementOrNode - existingElementOrNode represents the
-   * element or node in the linked list before which you want to add a new element or node.
-   * @param {E | SinglyLinkedListNode<E>} newElementOrNode - The `newElementOrNode` parameter in the
-   * `addBefore` method represents the element or node that you want to insert before the existing
-   * element or node in the linked list. This new element can be of type `E` or a
-   * `SinglyLinkedListNode<E>`.
-   * @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 operation was
-   * unsuccessful.
-   */
-  addBefore(existingElementOrNode, newElementOrNode) {
-    const existingNode = this.getNode(existingElementOrNode);
-    if (!existingNode) return false;
-    const prevNode = this._getPrevNode(existingNode);
-    const newNode = this._ensureNode(newElementOrNode);
-    if (!prevNode) {
-      this.unshift(newNode);
-    } else {
-      prevNode.next = newNode;
-      newNode.next = existingNode;
-      this._length++;
-    }
-    return true;
-  }
-  /**
-   * Time Complexity: 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 singly linked list.
-   * @param {E | SinglyLinkedListNode<E>} existingElementOrNode - existingElementOrNode can be either
-   * an element of type E or a SinglyLinkedListNode of type E.
-   * @param {E | SinglyLinkedListNode<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 singly linked list. This parameter can be either the value of the new element or a
-   * reference to a `SinglyLinkedListNode` containing
-   * @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.
-   */
-  addAfter(existingElementOrNode, newElementOrNode) {
-    const existingNode = this.getNode(existingElementOrNode);
-    if (existingNode) {
-      const newNode = this._ensureNode(newElementOrNode);
-      newNode.next = existingNode.next;
-      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 `splice` in TypeScript overrides the default behavior to remove and insert elements
-   * in a singly linked list while handling boundary cases.
-   * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
-   * to start modifying the list. It specifies the position where elements will be added or removed.
-   * @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 to be
-   * inserted into the list at the specified `start` index. These elements will be inserted in place of
-   * the elements that are removed from the list. The `splice` method allows you to add new elements to
-   * the list while
-   * @returns The `splice` method is returning a `SinglyLinkedList` containing the elements that were
-   * removed from the original list during the splice operation.
-   */
-  splice(start, deleteCount = 0, ...items) {
-    const removedList = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
-    start = Math.max(0, Math.min(start, this.length));
-    deleteCount = Math.max(0, deleteCount);
-    const prevNode = start === 0 ? void 0 : this.getNodeAt(start - 1);
-    const startNode = prevNode ? prevNode.next : this.head;
-    let current = startNode;
-    for (let i = 0; i < deleteCount && current; i++) {
-      removedList.push(current.value);
-      current = current.next;
-    }
-    const nextNode = current;
-    let lastInsertedNode = void 0;
-    for (const item of items) {
-      const newNode = this._ensureNode(item);
-      if (!lastInsertedNode) {
-        if (prevNode) {
-          prevNode.next = newNode;
-        } else {
-          this._head = newNode;
-        }
-      } else {
-        lastInsertedNode.next = newNode;
-      }
-      lastInsertedNode = newNode;
-    }
-    if (lastInsertedNode) {
-      lastInsertedNode.next = nextNode;
-    } else if (prevNode) {
-      prevNode.next = nextNode;
-    }
-    if (!nextNode) {
-      this._tail = lastInsertedNode || prevNode;
-    }
-    this._length += items.length - removedList.length;
-    return removedList;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `countOccurrences` iterates through a singly linked list and counts the occurrences
-   * of a specified element or nodes that satisfy a given predicate.
-   * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<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 singly 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;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `clone` function returns a new instance of the `SinglyLinkedList` class with the same values
-   * as the original list.
-   * @returns The `clone()` method is returning a new instance of the `SinglyLinkedList` class, which
-   * is a clone of the original list.
-   */
-  clone() {
-    return new _SinglyLinkedList(this, { toElementFn: this.toElementFn, maxLen: this._maxLen });
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `filter` function creates a new SinglyLinkedList by iterating over the elements of the current
-   * list and applying a callback function to each element to determine if it should be included in the
-   * filtered list.
-   * @param callback - The callback parameter is a function that will be called for each element in the
-   * list. It takes three arguments: the current element, the index of the current element, and the
-   * list itself. The callback function should return a boolean value indicating whether the current
-   * element should be included in the filtered list or not
-   * @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 `SinglyLinkedList` 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 SinglyLinkedList 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 list. It takes three arguments: `current` (the current element being processed),
-   * `index` (the index of the current element), and `this` (the original list). It should return a
-   * value
-   * @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 `SinglyLinkedList` class with the mapped elements.
-   */
-  map(callback, toElementFn, thisArg) {
-    const mappedList = new _SinglyLinkedList([], { toElementFn, maxLen: this._maxLen });
-    let index = 0;
-    for (const current of this) {
-      mappedList.push(callback.call(thisArg, current, index, this));
-      index++;
-    }
-    return mappedList;
-  }
-  /**
-   * The function `_createInstance` returns a new instance of `SinglyLinkedList` with the specified
-   * options.
-   * @param [options] - The `options` parameter in the `_createInstance` method is of type
-   * `SinglyLinkedListOptions<E, R>`, which is used to configure the behavior of the `SinglyLinkedList`
-   * instance being created. It is an optional parameter, meaning it can be omitted when calling the
-   * method.
-   * @returns An instance of the `SinglyLinkedList` class with an empty array and the provided options
-   * is being returned.
-   */
-  _createInstance(options) {
-    return new _SinglyLinkedList([], options);
-  }
-  /**
-   * The function `_getIterator` returns an iterable iterator that yields 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 collection in reverse order.
-   */
-  *_getReverseIterator() {
-    const reversedArr = [...this].reverse();
-    for (const item of reversedArr) {
-      yield item;
-    }
-  }
-  /**
-   * The function `_getNodeIterator` returns an iterator that iterates over the nodes of a singly
-   * linked list.
-   */
-  *_getNodeIterator() {
-    let current = this.head;
-    while (current) {
-      yield current;
-      current = current.next;
-    }
-  }
-  // protected *_getReverseNodeIterator(): IterableIterator<SinglyLinkedListNode<E>> {
-  //   const reversedArr = [...this._getNodeIterator()].reverse();
-  //
-  //   for (const item of reversedArr) {
-  //     yield item;
-  //   }
-  // }
-  /**
-   * The _isPredicate function in TypeScript checks if the input is a function that takes a
-   * SinglyLinkedListNode as an argument and returns a boolean.
-   * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following types:
-   * @returns The _isPredicate method is returning a boolean value based on 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. If it is not a
-   * function, the method will return false.
-   */
-  _isPredicate(elementNodeOrPredicate) {
-    return typeof elementNodeOrPredicate === "function";
-  }
-  /**
-   * The function `_ensureNode` ensures that the input is a valid node and returns it, creating a new
-   * node if necessary.
-   * @param {E | SinglyLinkedListNode<E>} elementOrNode - The `elementOrNode` parameter can be either
-   * an element of type `E` or a `SinglyLinkedListNode` containing an element of type `E`.
-   * @returns A SinglyLinkedListNode<E> object is being returned.
-   */
-  _ensureNode(elementOrNode) {
-    if (this.isNode(elementOrNode)) return elementOrNode;
-    return new SinglyLinkedListNode(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 | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter can be one of the following types:
-   * @returns A function is being returned. If the input `elementNodeOrPredicate` is already a node, a
-   * function is returned that checks if a given node is equal to the input node. If the input is a
-   * predicate function, it is returned as is. If the input is neither a node nor a predicate function,
-   * a function is returned that checks if a given node's value is equal to the input
-   */
-  _ensurePredicate(elementNodeOrPredicate) {
-    if (this.isNode(elementNodeOrPredicate)) return (node) => node === elementNodeOrPredicate;
-    if (this._isPredicate(elementNodeOrPredicate)) return elementNodeOrPredicate;
-    return (node) => node.value === elementNodeOrPredicate;
-  }
-  /**
-   * The function `_getPrevNode` returns the node before a given node in a singly linked list.
-   * @param node - The `node` parameter in the `_getPrevNode` method is a reference to a node in a
-   * singly linked list. The method is used to find the node that comes before the given node in the
-   * linked list.
-   * @returns The `_getPrevNode` method returns either the previous node of the input node in a singly
-   * linked list or `undefined` if the input node is the head of the list or if the input node is not
-   * found in the list.
-   */
-  _getPrevNode(node) {
-    if (!this.head || this.head === node) return void 0;
-    let current = this.head;
-    while (current.next && current.next !== node) {
-      current = current.next;
-    }
-    return current.next === node ? current : void 0;
-  }
-};
-export {
-  SinglyLinkedList,
-  SinglyLinkedListNode
-};
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */