data-structure-typed 2.0.0 → 2.0.1

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

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