data-structure-typed 2.0.1 → 2.0.3

package/dist/individuals/binary-tree/tree-multi-map.mjs

@@ -1,4582 +0,0 @@
-// src/utils/utils.ts
-var THUNK_SYMBOL = Symbol("thunk");
-var isThunk = (fnOrValue) => {
-  return typeof fnOrValue === "function" && fnOrValue.__THUNK__ === THUNK_SYMBOL;
-};
-var toThunk = (fn) => {
-  const thunk = () => fn();
-  thunk.__THUNK__ = THUNK_SYMBOL;
-  return thunk;
-};
-var trampoline = (fn) => {
-  const cont = (...args) => toThunk(() => fn(...args));
-  return Object.assign(
-    (...args) => {
-      let result = fn(...args);
-      while (isThunk(result) && typeof result === "function") {
-        result = result();
-      }
-      return result;
-    },
-    { cont }
-  );
-};
-function isPrimitiveComparable(value) {
-  const valueType = typeof value;
-  if (valueType === "number") return true;
-  return valueType === "bigint" || valueType === "string" || valueType === "boolean";
-}
-function tryObjectToPrimitive(obj) {
-  if (typeof obj.valueOf === "function") {
-    const valueOfResult = obj.valueOf();
-    if (valueOfResult !== obj) {
-      if (isPrimitiveComparable(valueOfResult)) return valueOfResult;
-      if (typeof valueOfResult === "object" && valueOfResult !== null) return tryObjectToPrimitive(valueOfResult);
-    }
-  }
-  if (typeof obj.toString === "function") {
-    const stringResult = obj.toString();
-    if (stringResult !== "[object Object]") return stringResult;
-  }
-  return null;
-}
-function isComparable(value, isForceObjectComparable = false) {
-  if (value === null || value === void 0) return false;
-  if (isPrimitiveComparable(value)) return true;
-  if (typeof value !== "object") return false;
-  if (value instanceof Date) return true;
-  if (isForceObjectComparable) return true;
-  const comparableValue = tryObjectToPrimitive(value);
-  if (comparableValue === null || comparableValue === void 0) return false;
-  return isPrimitiveComparable(comparableValue);
-}
-
-// src/data-structures/base/iterable-element-base.ts
-var IterableElementBase = class {
-  /**
-   * The protected constructor initializes the options for the IterableElementBase class, including the
-   * toElementFn function.
-   * @param [options] - An optional object that contains the following properties:
-   */
-  constructor(options) {
-    if (options) {
-      const { toElementFn } = options;
-      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
-    }
-  }
-  _toElementFn;
-  get toElementFn() {
-    return this._toElementFn;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function is an implementation of the Symbol.iterator method that returns an IterableIterator.
-   * @param {any[]} args - The `args` parameter in the code snippet represents a rest parameter. It
-   * allows the function to accept any number of arguments as an array. In this case, the `args`
-   * parameter is used to pass any number of arguments to the `_getIterator` method.
-   */
-  *[Symbol.iterator](...args) {
-    yield* this._getIterator(...args);
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function returns an iterator that yields all the values in the object.
-   */
-  *values() {
-    for (const item of this) {
-      yield item;
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `every` function checks if every element in the array satisfies a given predicate.
-   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
-   * the current element being processed, its index, and the array it belongs to. It should return a
-   * boolean value indicating whether the element satisfies a certain condition or not.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
-   * passed as the `this` value to the `predicate` function. If `thisArg` is
-   * @returns The `every` method is returning a boolean value. It returns `true` if every element in
-   * the array satisfies the provided predicate function, and `false` otherwise.
-   */
-  every(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (!predicate.call(thisArg, item, index++, this)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The "some" function checks if at least one element in a collection satisfies a given predicate.
-   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
-   * `value`, `index`, and `array`. It should return a boolean value indicating whether the current
-   * element satisfies the condition.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
-   * it will be passed as the `this` value to the `predicate` function. If `thisArg
-   * @returns a boolean value. It returns true if the predicate function returns true for any element
-   * in the collection, and false otherwise.
-   */
-  some(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (predicate.call(thisArg, item, index++, this)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `forEach` function iterates over each element in an array-like object and calls a callback
-   * function for each element.
-   * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
-   * the array. It takes three arguments: the current element being processed, the index of the current
-   * element, and the array that forEach was called upon.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
-   * be passed as the `this` value to the `callbackfn` function. If `thisArg
-   */
-  forEach(callbackfn, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      callbackfn.call(thisArg, item, index++, this);
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `find` function iterates over the elements of an array-like object and returns the first
-   * element that satisfies the provided callback function.
-   * @param predicate - The predicate parameter is a function that will be called for each element in
-   * the array. It takes three arguments: the current element being processed, the index of the current
-   * element, and the array itself. The function should return a boolean value indicating whether the
-   * current element matches the desired condition.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
-   * be passed as the `this` value to the `callbackfn` function. If `thisArg
-   * @returns The `find` method returns the first element in the array that satisfies the provided
-   * callback function. If no element satisfies the callback function, `undefined` is returned.
-   */
-  find(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (predicate.call(thisArg, item, index++, this)) return item;
-    }
-    return;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given element exists in a collection.
-   * @param {E} element - The parameter "element" is of type E, which means it can be any type. It
-   * represents the element that we want to check for existence in the collection.
-   * @returns a boolean value. It returns true if the element is found in the collection, and false
-   * otherwise.
-   */
-  has(element) {
-    for (const ele of this) {
-      if (ele === element) return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `reduce` function iterates over the elements of an array-like object and applies a callback
-   * function to reduce them into a single value.
-   * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
-   * the array. It takes four arguments:
-   * @param {U} initialValue - The initialValue parameter is the initial value of the accumulator. It
-   * is the value that the accumulator starts with before the reduction operation begins.
-   * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-   * all the elements in the array and applying the callback function to each element.
-   */
-  reduce(callbackfn, initialValue) {
-    let accumulator = initialValue ?? 0;
-    let index = 0;
-    for (const item of this) {
-      accumulator = callbackfn(accumulator, item, index++, this);
-    }
-    return accumulator;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `toArray` function converts a linked list into an array.
-   * @returns The `toArray()` method is returning an array of type `E[]`.
-   */
-  toArray() {
-    return [...this];
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The print function logs the elements of an array to the console.
-   */
-  toVisual() {
-    return [...this];
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The print function logs the elements of an array to the console.
-   */
-  print() {
-    console.log(this.toVisual());
-  }
-};
-
-// src/data-structures/base/linear-base.ts
-var LinearBase = class _LinearBase extends IterableElementBase {
-  /**
-   * The constructor initializes the LinearBase class with optional options, setting the maximum length
-   * if provided.
-   * @param [options] - The `options` parameter is an optional object that can be passed to the
-   * constructor. It is of type `LinearBaseOptions<E, R>`. The constructor checks if the `options`
-   * object is provided and then extracts the `maxLen` property from it. If `maxLen` is a
-   */
-  constructor(options) {
-    super(options);
-    if (options) {
-      const { maxLen } = options;
-      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
-    }
-  }
-  _maxLen = -1;
-  get maxLen() {
-    return this._maxLen;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function indexOf searches for a specified element starting from a given index in an array-like
-   * object and returns the index of the first occurrence, or -1 if not found.
-   * @param {E} searchElement - The `searchElement` parameter in the `indexOf` function represents the
-   * element that you want to find within the array. The function will search for this element starting
-   * from the `fromIndex` (if provided) up to the end of the array. If the `searchElement` is found
-   * within the
-   * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` function represents the
-   * index at which to start searching for the `searchElement` within the array. If provided, the
-   * search will begin at this index and continue to the end of the array. If `fromIndex` is not
-   * specified, the default
-   * @returns The `indexOf` method is returning the index of the `searchElement` if it is found in the
-   * array starting from the `fromIndex`. If the `searchElement` is not found, it returns -1.
-   */
-  indexOf(searchElement, fromIndex = 0) {
-    if (this.length === 0) return -1;
-    if (fromIndex < 0) fromIndex = this.length + fromIndex;
-    if (fromIndex < 0) fromIndex = 0;
-    for (let i = fromIndex; i < this.length; i++) {
-      const element = this.at(i);
-      if (element === searchElement) return i;
-    }
-    return -1;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `lastIndexOf` in TypeScript returns the index of the last occurrence of a specified
-   * element in an array.
-   * @param {E} searchElement - The `searchElement` parameter is the element that you want to find the
-   * last index of within the array. The `lastIndexOf` method will search the array starting from the
-   * `fromIndex` (or the end of the array if not specified) and return the index of the last occurrence
-   * of the
-   * @param {number} fromIndex - The `fromIndex` parameter in the `lastIndexOf` method specifies the
-   * index at which to start searching for the `searchElement` in the array. By default, it starts
-   * searching from the last element of the array (`this.length - 1`). If a specific `fromIndex` is
-   * provided
-   * @returns The last index of the `searchElement` in the array is being returned. If the
-   * `searchElement` is not found in the array, -1 is returned.
-   */
-  lastIndexOf(searchElement, fromIndex = this.length - 1) {
-    if (this.length === 0) return -1;
-    if (fromIndex >= this.length) fromIndex = this.length - 1;
-    if (fromIndex < 0) fromIndex = this.length + fromIndex;
-    for (let i = fromIndex; i >= 0; i--) {
-      const element = this.at(i);
-      if (element === searchElement) return i;
-    }
-    return -1;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `findIndex` function iterates over an array and returns the index of the first element that
-   * satisfies the provided predicate function.
-   * @param predicate - The `predicate` parameter in the `findIndex` function is a callback function
-   * that takes three arguments: `item`, `index`, and the array `this`. It should return a boolean
-   * value indicating whether the current element satisfies the condition being checked for.
-   * @param {any} [thisArg] - The `thisArg` parameter in the `findIndex` function is an optional
-   * parameter that specifies the value to use as `this` when executing the `predicate` function. If
-   * provided, the `predicate` function will be called with `thisArg` as its `this` value. If `
-   * @returns The `findIndex` method is returning the index of the first element in the array that
-   * satisfies the provided predicate function. If no such element is found, it returns -1.
-   */
-  findIndex(predicate, thisArg) {
-    for (let i = 0; i < this.length; i++) {
-      const item = this.at(i);
-      if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
-    }
-    return -1;
-  }
-  /**
-   * Time Complexity: O(n + m)
-   * Space Complexity: O(n + m)
-   *
-   * The `concat` function in TypeScript concatenates multiple items into a new list, handling both
-   * individual elements and instances of `LinearBase`.
-   * @param {(E | this)[]} items - The `concat` method takes in an array of items, where
-   * each item can be either of type `E` or an instance of `LinearBase<E, R>`.
-   * @returns The `concat` method is returning a new instance of the class that it belongs to, with the
-   * items passed as arguments concatenated to it.
-   */
-  concat(...items) {
-    const newList = this.clone();
-    for (const item of items) {
-      if (item instanceof _LinearBase) {
-        newList.pushMany(item);
-      } else {
-        newList.push(item);
-      }
-    }
-    return newList;
-  }
-  /**
-   * Time Complexity: O(n log n)
-   * Space Complexity: O(n)
-   *
-   * The `sort` function in TypeScript sorts the elements of a collection using a specified comparison
-   * function.
-   * @param [compareFn] - The `compareFn` parameter is a function that defines the sort order. It takes
-   * two elements `a` and `b` as input and returns a number indicating their relative order. If the
-   * returned value is negative, `a` comes before `b`. If the returned value is positive, `
-   * @returns The `sort` method is returning the instance of the object on which it is called (this),
-   * after sorting the elements based on the provided comparison function (compareFn).
-   */
-  sort(compareFn) {
-    const arr = this.toArray();
-    arr.sort(compareFn);
-    this.clear();
-    for (const item of arr) this.push(item);
-    return this;
-  }
-  /**
-   * Time Complexity: O(n + m)
-   * Space Complexity: O(m)
-   *
-   * The `splice` function in TypeScript removes elements from an array and optionally inserts new
-   * elements at the specified index.
-   * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
-   * to start modifying the array. If `start` is a negative number, it will count from the end of the
-   * array.
-   * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
-   * number of elements to remove from the array starting at the specified `start` index. If
-   * `deleteCount` is not provided or is 0, no elements are removed, and only new elements are inserted
-   * at the `start`
-   * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
-   * will be inserted into the array at the specified `start` index. These elements can be of any type
-   * and you can pass multiple elements separated by commas. The `splice` method will insert these
-   * items into the array at the
-   * @returns The `splice` method returns a list of elements that were removed from the original list
-   * during the operation.
-   */
-  splice(start, deleteCount = 0, ...items) {
-    const removedList = this._createInstance();
-    start = start < 0 ? this.length + start : start;
-    start = Math.max(0, Math.min(start, this.length));
-    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
-    for (let i = 0; i < deleteCount; i++) {
-      const removed = this.deleteAt(start);
-      if (removed !== void 0) {
-        removedList.push(removed);
-      }
-    }
-    for (let i = 0; i < items.length; i++) {
-      this.addAt(start + i, items[i]);
-    }
-    return removedList;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `join` function in TypeScript returns a string by joining the elements of an array with a
-   * specified separator.
-   * @param {string} [separator=,] - The `separator` parameter is a string that specifies the character
-   * or characters that will be used to separate each element when joining them into a single string.
-   * By default, the separator is set to a comma (`,`), but you can provide a different separator if
-   * needed.
-   * @returns The `join` method is being returned, which takes an optional `separator` parameter
-   * (defaulting to a comma) and returns a string created by joining all elements of the array after
-   * converting it to an array.
-   */
-  join(separator = ",") {
-    return this.toArray().join(separator);
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function `toReversedArray` takes an array and returns a new array with its elements in reverse
-   * order.
-   * @returns The `toReversedArray()` function returns an array of elements of type `E` in reverse
-   * order.
-   */
-  toReversedArray() {
-    const array = [];
-    for (let i = this.length - 1; i >= 0; i--) {
-      array.push(this.at(i));
-    }
-    return array;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `reduceRight` function in TypeScript iterates over an array from right to left and applies a
-   * callback function to each element, accumulating a single result.
-   * @param callbackfn - The `callbackfn` parameter in the `reduceRight` method is a function that will
-   * be called on each element in the array from right to left. It takes four arguments:
-   * @param {U} [initialValue] - The `initialValue` parameter in the `reduceRight` method is an
-   * optional parameter that specifies the initial value of the accumulator. If provided, the
-   * `accumulator` will start with this initial value before iterating over the elements of the array.
-   * If `initialValue` is not provided, the accumulator will
-   * @returns The `reduceRight` method is returning the final accumulated value after applying the
-   * callback function to each element in the array from right to left.
-   */
-  reduceRight(callbackfn, initialValue) {
-    let accumulator = initialValue ?? 0;
-    for (let i = this.length - 1; i >= 0; i--) {
-      accumulator = callbackfn(accumulator, this.at(i), i, this);
-    }
-    return accumulator;
-  }
-  /**
-   * Time Complexity: O(m)
-   * Space Complexity: O(m)
-   *
-   * The `slice` function in TypeScript creates a new instance by extracting a portion of elements from
-   * the original instance based on the specified start and end indices.
-   * @param {number} [start=0] - The `start` parameter in the `slice` method represents the index at
-   * which to begin extracting elements from an array-like object. If no `start` parameter is provided,
-   * the default value is 0, meaning the extraction will start from the beginning of the array.
-   * @param {number} end - The `end` parameter in the `slice` method represents the index at which to
-   * end the slicing. By default, if no `end` parameter is provided, it will slice until the end of the
-   * array (i.e., `this.length`).
-   * @returns The `slice` method is returning a new instance of the object with elements sliced from
-   * the specified start index (default is 0) to the specified end index (default is the length of the
-   * object).
-   */
-  slice(start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    const newList = this._createInstance();
-    for (let i = start; i < end; i++) {
-      newList.push(this.at(i));
-    }
-    return newList;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `fill` function in TypeScript fills a specified range in an array-like object with a given
-   * value.
-   * @param {E} value - The `value` parameter in the `fill` method represents the element that will be
-   * used to fill the specified range in the array.
-   * @param [start=0] - The `start` parameter specifies the index at which to start filling the array
-   * with the specified value. If not provided, it defaults to 0, indicating the beginning of the
-   * array.
-   * @param end - The `end` parameter in the `fill` function represents the index at which the filling
-   * of values should stop. It specifies the end of the range within the array where the `value` should
-   * be filled.
-   * @returns The `fill` method is returning the modified object (`this`) after filling the specified
-   * range with the provided value.
-   */
-  fill(value, start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    if (start < 0) start = 0;
-    if (end > this.length) end = this.length;
-    if (start >= end) return this;
-    for (let i = start; i < end; i++) {
-      this.setAt(i, value);
-    }
-    return this;
-  }
-};
-
-// src/data-structures/queue/queue.ts
-var Queue = class _Queue extends LinearBase {
-  constructor(elements = [], options) {
-    super(options);
-    if (options) {
-      const { autoCompactRatio = 0.5 } = options;
-      this._autoCompactRatio = autoCompactRatio;
-    }
-    this.pushMany(elements);
-  }
-  _elements = [];
-  get elements() {
-    return this._elements;
-  }
-  _offset = 0;
-  get offset() {
-    return this._offset;
-  }
-  get length() {
-    return this.elements.length - this.offset;
-  }
-  _autoCompactRatio = 0.5;
-  get autoCompactRatio() {
-    return this._autoCompactRatio;
-  }
-  set autoCompactRatio(v) {
-    this._autoCompactRatio = v;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
-   * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
-   * the `_offset` index. If the data structure is empty (length is 0), it returns `undefined`.
-   */
-  get first() {
-    return this.length > 0 ? this.elements[this.offset] : void 0;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-   * @returns The method `get last()` returns the last element of the `_elements` array if the array is not empty. If the
-   * array is empty, it returns `undefined`.
-   */
-  get last() {
-    return this.length > 0 ? this.elements[this.elements.length - 1] : void 0;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
-   * @public
-   * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
-   * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
-   * array.
-   */
-  static fromArray(elements) {
-    return new _Queue(elements);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The push function adds an element to the end of the queue and returns true. Adds an element at the back of the queue.
-   * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
-   * @returns Always returns true, indicating the element was successfully added.
-   */
-  push(element) {
-    this.elements.push(element);
-    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
-    return true;
-  }
-  /**
-   * Time Complexity: O(k)
-   * Space Complexity: O(k)
-   *
-   * The `pushMany` function iterates over elements and pushes them into an array after applying a
-   * transformation function if provided.
-   * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `pushMany` function
-   * is an iterable containing elements of type `E` or `R`.
-   * @returns The `pushMany` function is returning 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)));
-      else ans.push(this.push(el));
-    }
-    return ans;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
-   * necessary to optimize performance.
-   * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
-   */
-  shift() {
-    if (this.length === 0) return void 0;
-    const first = this.first;
-    this._offset += 1;
-    if (this.offset / this.elements.length > this.autoCompactRatio) this.compact();
-    return first;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The delete function removes an element from the list.
-   * @param {E} element - Specify the element to be deleted
-   * @return A boolean value indicating whether the element was successfully deleted or not
-   */
-  delete(element) {
-    const index = this.elements.indexOf(element);
-    return !!this.deleteAt(index);
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The deleteAt function deletes the element at a given index.
-   * @param {number} index - Determine the index of the element to be deleted
-   * @return A boolean value
-   */
-  deleteAt(index) {
-    const deleted = this.elements[index];
-    this.elements.splice(index, 1);
-    return deleted;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `at` function returns the element at a specified index adjusted by an offset, or `undefined`
-   * if the index is out of bounds.
-   * @param {number} index - The `index` parameter represents the position of the element you want to
-   * retrieve from the data structure.
-   * @returns The `at` method is returning the element at the specified index adjusted by the offset
-   * `_offset`.
-   */
-  at(index) {
-    return this.elements[index + this._offset];
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `reverse` function in TypeScript reverses the elements of an array starting from a specified
-   * offset.
-   * @returns The `reverse()` method is returning the modified object itself (`this`) after reversing
-   * the elements in the array and resetting the offset to 0.
-   */
-  reverse() {
-    this._elements = this.elements.slice(this.offset).reverse();
-    this._offset = 0;
-    return this;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `addAt` inserts a new element at a specified index in an array, returning true if
-   * successful and false if the index is out of bounds.
-   * @param {number} index - The `index` parameter represents the position at which the `newElement`
-   * should be added in the array.
-   * @param {E} newElement - The `newElement` parameter represents the element that you want to insert
-   * into the array at the specified index.
-   * @returns The `addAt` method returns a boolean value - `true` if the new element was successfully
-   * added at the specified index, and `false` if the index is out of bounds (less than 0 or greater
-   * than the length of the array).
-   */
-  addAt(index, newElement) {
-    if (index < 0 || index > this.length) return false;
-    this._elements.splice(this.offset + index, 0, newElement);
-    return true;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `setAt` updates an element at a specified index in an array-like data structure.
-   * @param {number} index - The `index` parameter is a number that represents the position in the
-   * array where the new element will be set.
-   * @param {E} newElement - The `newElement` parameter represents the new value that you want to set
-   * at the specified index in the array.
-   * @returns The `setAt` method returns a boolean value - `true` if the element was successfully set
-   * at the specified index, and `false` if the index is out of bounds (less than 0 or greater than the
-   * length of the array).
-   */
-  setAt(index, newElement) {
-    if (index < 0 || index > this.length) return false;
-    this._elements[this.offset + index] = newElement;
-    return true;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a data structure is empty by comparing its length to zero.
-   * @returns {boolean} A boolean value indicating whether the length of the object is 0 or not.
-   */
-  isEmpty() {
-    return this.length === 0;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The clear function resets the elements array and offset to their initial values.
-   */
-  clear() {
-    this._elements = [];
-    this._offset = 0;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `compact` function in TypeScript slices the elements array based on the offset and resets the
-   * offset to zero.
-   * @returns The `compact()` method is returning a boolean value of `true`.
-   */
-  compact() {
-    this._elements = this.elements.slice(this.offset);
-    this._offset = 0;
-    return true;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function overrides the splice method to remove and insert elements in a queue-like data
-   * structure.
-   * @param {number} start - The `start` parameter in the `splice` method specifies the index at which
-   * to start changing the array. Items will be added or removed starting from this index.
-   * @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 added to the array at the specified `start` index. These elements will replace the
-   * existing elements starting from the `start` index for the `deleteCount` number of elements.
-   * @returns The `splice` method is returning the `removedQueue`, which is an instance of the same
-   * class as the original object.
-   */
-  splice(start, deleteCount = 0, ...items) {
-    const removedQueue = this._createInstance();
-    start = Math.max(0, Math.min(start, this.length));
-    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
-    const globalStartIndex = this.offset + start;
-    const removedElements = this._elements.splice(globalStartIndex, deleteCount, ...items);
-    removedQueue.pushMany(removedElements);
-    this.compact();
-    return removedQueue;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `clone()` function returns a new Queue object with the same elements as the original Queue.
-   * @returns The `clone()` method is returning a new instance of the `Queue` class.
-   */
-  clone() {
-    return new _Queue(this.elements.slice(this.offset), { toElementFn: this.toElementFn, maxLen: this._maxLen });
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `filter` function creates a new `Queue` object containing elements from the original `Queue`
-   * that satisfy a given predicate function.
-   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
-   * the current element being iterated over, the index of the current element, and the queue itself.
-   * It should return a boolean value indicating whether the element should be included in the filtered
-   * queue or not.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
-   * passed as the `this` value to the `predicate` function. If `thisArg` is
-   * @returns The `filter` method is returning a new `Queue` object that contains the elements that
-   * satisfy the given predicate function.
-   */
-  filter(predicate, thisArg) {
-    const newDeque = this._createInstance({
-      toElementFn: this._toElementFn,
-      autoCompactRatio: this._autoCompactRatio,
-      maxLen: this._maxLen
-    });
-    let index = 0;
-    for (const el of this) {
-      if (predicate.call(thisArg, el, index, this)) {
-        newDeque.push(el);
-      }
-      index++;
-    }
-    return newDeque;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `map` function in TypeScript creates a new Queue by applying a callback function to each
-   * element in the original Queue.
-   * @param callback - The `callback` parameter is a function that will be applied to each element in
-   * the queue. It takes the current element, its index, and the queue itself as arguments, and returns
-   * a new element.
-   * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be provided to
-   * convert a raw element of type `RM` to a new element of type `EM`. This function is used within the
-   * `map` method to transform each raw element before passing it to the `callback` function. If
-   * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is used to specify the
-   * value of `this` when executing the `callback` function. It allows you to set the context (the
-   * value of `this`) within the callback function. If `thisArg` is provided, it will be
-   * @returns A new Queue object containing elements of type EM, which are the result of applying the
-   * callback function to each element in the original Queue object.
-   */
-  map(callback, toElementFn, thisArg) {
-    const newDeque = new _Queue([], {
-      toElementFn,
-      autoCompactRatio: this._autoCompactRatio,
-      maxLen: this._maxLen
-    });
-    let index = 0;
-    for (const el of this) {
-      newDeque.push(callback.call(thisArg, el, index, this));
-      index++;
-    }
-    return newDeque;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function `_getIterator` returns an iterable iterator for the elements in the class.
-   */
-  *_getIterator() {
-    for (const item of this.elements.slice(this.offset)) {
-      yield item;
-    }
-  }
-  /**
-   * The function `_createInstance` returns a new instance of the `Queue` class with the specified
-   * options.
-   * @param [options] - The `options` parameter in the `_createInstance` method is of type
-   * `QueueOptions<E, R>`, which is used to configure the behavior of the queue being created. It
-   * allows you to specify settings or properties that can influence how the queue operates.
-   * @returns An instance of the `Queue` class with an empty array and the provided options is being
-   * returned.
-   */
-  _createInstance(options) {
-    return new _Queue([], options);
-  }
-  /**
-   * The function `_getReverseIterator` returns an iterator that iterates over elements in reverse
-   * order.
-   */
-  *_getReverseIterator() {
-    for (let i = this.length - 1; i >= 0; i--) {
-      const cur = this.at(i);
-      if (cur !== void 0) yield cur;
-    }
-  }
-};
-
-// src/data-structures/base/iterable-entry-base.ts
-var IterableEntryBase = class {
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function is an implementation of the Symbol.iterator method that returns an iterable iterator.
-   * @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 additional 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 key-value pairs from the object, where the value can
-   * be undefined.
-   */
-  *entries() {
-    for (const item of this) {
-      yield item;
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function returns an iterator that yields the keys of a data structure.
-   */
-  *keys() {
-    for (const item of this) {
-      yield item[0];
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function returns an iterator that yields the values of a collection.
-   */
-  *values() {
-    for (const item of this) {
-      yield item[1];
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `every` function checks if every element in a collection satisfies a given condition.
-   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
-   * `value`, `key`, and `index`. It should return a boolean value indicating whether the condition is
-   * met for the current element in the iteration.
-   * @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 first argument to the `predicate` function. If `thisArg` is not provided
-   * @returns The `every` method is returning a boolean value. It returns `true` if every element in
-   * the collection satisfies the provided predicate function, and `false` otherwise.
-   */
-  every(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (!predicate.call(thisArg, item[0], item[1], index++, this)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The "some" function iterates over a collection and returns true if at least one element satisfies
-   * a given predicate.
-   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
-   * `value`, `key`, and `index`. It should return a boolean value indicating whether the condition is
-   * met for the current element in the iteration.
-   * @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 first argument to the `predicate` function. If `thisArg` is
-   * @returns a boolean value. It returns true if the predicate function returns true for any pair in
-   * the collection, and false otherwise.
-   */
-  some(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (predicate.call(thisArg, item[0], item[1], index++, this)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `forEach` function iterates over each key-value pair in a collection and executes a callback
-   * function for each pair.
-   * @param callbackfn - The callback function that will be called for each element in the collection.
-   * It takes four parameters: the value of the current element, the key of the current element, the
-   * index of the current element, and the collection itself.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-   * specify the value of `this` within the callback function. If `thisArg` is provided, it will be
-   * used as the `this` value when calling the callback function. If `thisArg` is not provided, `
-   */
-  forEach(callbackfn, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      callbackfn.call(thisArg, key, value, index++, this);
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `find` function iterates over the entries of a collection and returns the first value for
-   * which the callback function returns true.
-   * @param callbackfn - The callback function that will be called for each entry in the collection. It
-   * takes three arguments: the value of the entry, the key of the entry, and the index of the entry in
-   * the collection. It should return a boolean value indicating whether the current entry 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 method `find` returns the value of the first element in the iterable that satisfies
-   * the provided callback function. If no element satisfies the callback function, `undefined` is
-   * returned.
-   */
-  find(callbackfn, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      if (callbackfn.call(thisArg, key, value, index++, this)) return item;
-    }
-    return;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given key exists in a collection.
-   * @param {K} key - The parameter "key" is of type K, which means it can be any type. It represents
-   * the key that we want to check for existence in the data structure.
-   * @returns a boolean value. It returns true if the key is found in the collection, and false
-   * otherwise.
-   */
-  has(key) {
-    for (const item of this) {
-      const [itemKey] = item;
-      if (itemKey === key) return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given value exists in a collection.
-   * @param {V} value - The parameter "value" is the value that we want to check if it exists in the
-   * collection.
-   * @returns a boolean value, either true or false.
-   */
-  hasValue(value) {
-    for (const [, elementValue] of this) {
-      if (elementValue === value) return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `get` function retrieves the value associated with a given key from a collection.
-   * @param {K} key - K (the type of the key) - This parameter represents the key that is being
-   * searched for in the collection.
-   * @returns The `get` method returns the value associated with the specified key if it exists in the
-   * collection, otherwise it returns `undefined`.
-   */
-  get(key) {
-    for (const item of this) {
-      const [itemKey, value] = item;
-      if (itemKey === key) return value;
-    }
-    return;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `reduce` function iterates over key-value pairs and applies a callback function to each pair,
-   * accumulating a single value.
-   * @param callbackfn - The callback function that will be called for each element in the collection.
-   * It takes four arguments: the current accumulator value, the current value of the element, the key
-   * of the element, and the index of the element in the collection. It should return the updated
-   * accumulator value.
-   * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-   * is the value that will be used as the first argument to the `callbackfn` function when reducing
-   * the elements of the collection.
-   * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-   * all the elements in the collection.
-   */
-  reduce(callbackfn, initialValue) {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      accumulator = callbackfn(accumulator, value, key, index++, this);
-    }
-    return accumulator;
-  }
-  /**
-   * 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/common/index.ts
-var Range = class {
-  constructor(low, high, includeLow = true, includeHigh = true) {
-    this.low = low;
-    this.high = high;
-    this.includeLow = includeLow;
-    this.includeHigh = includeHigh;
-    if (!(isComparable(low) && isComparable(high))) throw new RangeError("low or high is not comparable");
-    if (low > high) throw new RangeError("low must be less than or equal to high");
-  }
-  // Determine whether a key is within the range
-  isInRange(key, comparator) {
-    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-    return lowCheck && highCheck;
-  }
-};
-
-// src/data-structures/binary-tree/binary-tree.ts
-var BinaryTreeNode = class {
-  key;
-  value;
-  parent = void 0;
-  /**
-   * The constructor function initializes an object with a key and an optional value in TypeScript.
-   * @param {K} key - The `key` parameter in the constructor function is used to store the key value
-   * for the key-value pair.
-   * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
-   * have to be provided when creating an instance of the class. If a `value` is not provided, it will
-   * default to `undefined`.
-   */
-  constructor(key, value) {
-    this.key = key;
-    this.value = value;
-  }
-  _left = void 0;
-  get left() {
-    return this._left;
-  }
-  set left(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._left = v;
-  }
-  _right = void 0;
-  get right() {
-    return this._right;
-  }
-  set right(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._right = v;
-  }
-  _height = 0;
-  get height() {
-    return this._height;
-  }
-  set height(value) {
-    this._height = value;
-  }
-  _color = "BLACK";
-  get color() {
-    return this._color;
-  }
-  set color(value) {
-    this._color = value;
-  }
-  _count = 1;
-  get count() {
-    return this._count;
-  }
-  set count(value) {
-    this._count = value;
-  }
-  get familyPosition() {
-    if (!this.parent) {
-      return this.left || this.right ? "ROOT" : "ISOLATED";
-    }
-    if (this.parent.left === this) {
-      return this.left || this.right ? "ROOT_LEFT" : "LEFT";
-    } else if (this.parent.right === this) {
-      return this.left || this.right ? "ROOT_RIGHT" : "RIGHT";
-    }
-    return "MAL_NODE";
-  }
-};
-var BinaryTree = class _BinaryTree extends IterableEntryBase {
-  iterationType = "ITERATIVE";
-  /**
-   * This TypeScript constructor function initializes a binary tree with optional options and adds
-   * elements based on the provided input.
-   * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain either objects of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
-   * is used to initialize the binary tree with keys, nodes, entries, or raw data.
-   * @param [options] - The `options` parameter in the constructor is an optional object that can
-   * contain the following properties:
-   */
-  constructor(keysNodesEntriesOrRaws = [], options) {
-    super();
-    if (options) {
-      const { iterationType, toEntryFn, isMapMode, isDuplicate } = options;
-      if (iterationType) this.iterationType = iterationType;
-      if (isMapMode !== void 0) this._isMapMode = isMapMode;
-      if (isDuplicate !== void 0) this._isDuplicate = isDuplicate;
-      if (typeof toEntryFn === "function") this._toEntryFn = toEntryFn;
-      else if (toEntryFn) throw TypeError("toEntryFn must be a function type");
-    }
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
-  }
-  _isMapMode = true;
-  get isMapMode() {
-    return this._isMapMode;
-  }
-  _isDuplicate = false;
-  get isDuplicate() {
-    return this._isDuplicate;
-  }
-  _store = /* @__PURE__ */ new Map();
-  get store() {
-    return this._store;
-  }
-  _root;
-  get root() {
-    return this._root;
-  }
-  _size = 0;
-  get size() {
-    return this._size;
-  }
-  _NIL = new BinaryTreeNode(NaN);
-  get NIL() {
-    return this._NIL;
-  }
-  _toEntryFn;
-  get toEntryFn() {
-    return this._toEntryFn;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function creates a new binary tree node with a specified key and optional value.
-   * @param {K} key - The `key` parameter is the key of the node being created in the binary tree.
-   * @param {V} [value] - The `value` parameter in the `createNode` function is optional, meaning it is
-   * not required to be provided when calling the function. If a `value` is provided, it should be of
-   * type `V`, which is the type of the value associated with the node.
-   * @returns A new BinaryTreeNode instance with the provided key and value is being returned, casted
-   * as BinaryTreeNode<K, V>.
-   */
-  createNode(key, value) {
-    return new BinaryTreeNode(key, this._isMapMode ? void 0 : value);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function creates a binary tree with the specified options.
-   * @param [options] - The `options` parameter in the `createTree` function is an optional parameter
-   * that allows you to provide partial configuration options for creating a binary tree. It is of type
-   * `Partial<BinaryTreeOptions<K, V, R>>`, which means you can pass in an object containing a subset
-   * of properties
-   * @returns A new instance of a binary tree with the specified options is being returned.
-   */
-  createTree(options) {
-    return new _BinaryTree([], {
-      iterationType: this.iterationType,
-      isMapMode: this._isMapMode,
-      toEntryFn: this._toEntryFn,
-      ...options
-    });
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * The function `ensureNode` in TypeScript checks if a given input is a node, entry, key, or raw
-   * value and returns the corresponding node or null.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `ensureNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
-   * is used to determine whether the input is a key, node, entry, or raw data. The
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `ensureNode` function
-   * is used to specify the type of iteration to be performed. It has a default value of
-   * `this.iterationType` if not explicitly provided.
-   * @returns The `ensureNode` function returns either a node, `null`, or `undefined` based on the
-   * conditions specified in the code snippet.
-   */
-  ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
-    if (keyNodeOrEntry === null) return null;
-    if (keyNodeOrEntry === void 0) return;
-    if (keyNodeOrEntry === this._NIL) return;
-    if (this.isNode(keyNodeOrEntry)) return keyNodeOrEntry;
-    if (this.isEntry(keyNodeOrEntry)) {
-      const key = keyNodeOrEntry[0];
-      if (key === null) return null;
-      if (key === void 0) return;
-      return this.getNode(key, this._root, iterationType);
-    }
-    return this.getNode(keyNodeOrEntry, this._root, iterationType);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function isNode checks if the input is an instance of BinaryTreeNode.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be either a key, a node, an entry, or raw data. The function is
-   * checking if the input is an instance of a `BinaryTreeNode` and returning a boolean value
-   * accordingly.
-   * @returns The function `isNode` is checking if the input `keyNodeOrEntry` is an instance of
-   * `BinaryTreeNode`. If it is, the function returns `true`, indicating that the input is a node. If
-   * it is not an instance of `BinaryTreeNode`, the function returns `false`, indicating that the input
-   * is not a node.
-   */
-  isNode(keyNodeOrEntry) {
-    return keyNodeOrEntry instanceof BinaryTreeNode;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | R} keyNodeEntryOrRaw - K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
-   * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
-   * checking if it is an object. If the parameter is an object, the function will return `true`,
-   * indicating that it is of type `R`.
-   */
-  isRaw(keyNodeEntryOrRaw) {
-    return this._toEntryFn !== void 0 && typeof keyNodeEntryOrRaw === "object";
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `isRealNode` checks if a given input is a valid node in a binary tree.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `isRealNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
-   * The function checks if the input parameter is a `BinaryTreeNode<K, V>` type by verifying if it is not equal
-   * @returns The function `isRealNode` is checking if the input `keyNodeOrEntry` is a valid
-   * node by comparing it to `this._NIL`, `null`, and `undefined`. If the input is not one of these
-   * values, it then calls the `isNode` method to further determine if the input is a node. The
-   * function will return a boolean value indicating whether the
-   */
-  isRealNode(keyNodeOrEntry) {
-    if (keyNodeOrEntry === this._NIL || keyNodeOrEntry === null || keyNodeOrEntry === void 0) return false;
-    return this.isNode(keyNodeOrEntry);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given input is a valid node or null.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` in the `isRealNodeOrNull` function can be of type `BTNRep<K,
-   * V, BinaryTreeNode<K, V>>` or `R`. It is a union type that can either be a key, a node, an entry, or
-   * @returns The function `isRealNodeOrNull` is returning a boolean value. It checks if the input
-   * `keyNodeOrEntry` is either `null` or a real node, and returns `true` if it is a node or
-   * `null`, and `false` otherwise.
-   */
-  isRealNodeOrNull(keyNodeOrEntry) {
-    return keyNodeOrEntry === null || this.isRealNode(keyNodeOrEntry);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function isNIL checks if a given key, node, entry, or raw value is equal to the _NIL value.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - BTNRep<K, V,
-   * BinaryTreeNode<K, V>>
-   * @returns The function is checking if the `keyNodeOrEntry` parameter is equal to the `_NIL`
-   * property of the current object and returning a boolean value based on that comparison.
-   */
-  isNIL(keyNodeOrEntry) {
-    return keyNodeOrEntry === this._NIL;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `isRange` checks if the input parameter is an instance of the `Range` class.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>> | Range<K>} keyNodeEntryOrPredicate
-   * - The `keyNodeEntryOrPredicate` parameter in the `isRange` function can be
-   * of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `, `NodePredicate<BinaryTreeNode<K, V>>`, or
-   * `Range<K>`. The function checks if the `keyNodeEntry
-   * @returns The `isRange` function is checking if the `keyNodeEntryOrPredicate` parameter is an
-   * instance of the `Range` class. If it is an instance of `Range`, the function will return `true`,
-   * indicating that the parameter is a `Range<K>`. If it is not an instance of `Range`, the function
-   * will return `false`.
-   */
-  isRange(keyNodeEntryOrPredicate) {
-    return keyNodeEntryOrPredicate instanceof Range;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
-   * tree.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It represents a
-   * key, node, entry, or raw data in a binary tree structure. The function `isLeaf` checks whether the
-   * provided
-   * @returns The function `isLeaf` returns a boolean value indicating whether the input
-   * `keyNodeOrEntry` is a leaf node in a binary tree.
-   */
-  isLeaf(keyNodeOrEntry) {
-    keyNodeOrEntry = this.ensureNode(keyNodeOrEntry);
-    if (keyNodeOrEntry === void 0) return false;
-    if (keyNodeOrEntry === null) return true;
-    return !this.isRealNode(keyNodeOrEntry.left) && !this.isRealNode(keyNodeOrEntry.right);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `isEntry` checks if the input is a BTNEntry object by verifying if it is an array
-   * with a length of 2.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `isEntry` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or type `R`.
-   * The function checks if the provided `keyNodeOrEntry` is of type `BTN
-   * @returns The `isEntry` function is checking if the `keyNodeOrEntry` parameter is an array
-   * with a length of 2. If it is, then it returns `true`, indicating that the parameter is of type
-   * `BTNEntry<K, V>`. If the condition is not met, it returns `false`.
-   */
-  isEntry(keyNodeOrEntry) {
-    return Array.isArray(keyNodeOrEntry) && keyNodeOrEntry.length === 2;
-  }
-  /**
-   * Time Complexity O(1)
-   * Space Complexity O(1)
-   *
-   * The function `isValidKey` checks if a given key is comparable.
-   * @param {any} key - The `key` parameter is of type `any`, which means it can be any data type in
-   * TypeScript.
-   * @returns The function `isValidKey` is checking if the `key` parameter is `null` or if it is comparable.
-   * If the `key` is `null`, the function returns `true`. Otherwise, it returns the result of the
-   * `isComparable` function, which is not provided in the code snippet.
-   */
-  isValidKey(key) {
-    if (key === null) return true;
-    return isComparable(key);
-  }
-  /**
-   * Time Complexity O(n)
-   * Space Complexity O(1)
-   *
-   * The `add` function in TypeScript adds a new node to a binary tree while handling duplicate keys
-   * and finding the correct insertion position.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `add` method you provided
-   * seems to be for adding a new node to a binary tree structure. The `keyNodeOrEntry`
-   * parameter in the method can accept different types of values:
-   * @param {V} [value] - The `value` parameter in the `add` method represents the value associated
-   * with the key that you want to add to the binary tree. When adding a key-value pair to the binary
-   * tree, you provide the key and its corresponding value. The `add` method then creates a new node
-   * with this
-   * @returns The `add` method returns a boolean value. It returns `true` if the insertion of the new
-   * node was successful, and `false` if the insertion position could not be found or if a duplicate
-   * key was found and the node was replaced instead of inserted.
-   */
-  add(keyNodeOrEntry, value) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
-    if (newNode === void 0) return false;
-    if (!this._root) {
-      this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
-      this._size = 1;
-      return true;
-    }
-    const queue = new Queue([this._root]);
-    let potentialParent;
-    while (queue.length > 0) {
-      const cur = queue.shift();
-      if (!cur) continue;
-      if (!this._isDuplicate) {
-        if (newNode !== null && cur.key === newNode.key) {
-          this._replaceNode(cur, newNode);
-          if (this._isMapMode) this._setValue(cur.key, newValue);
-          return true;
-        }
-      }
-      if (potentialParent === void 0 && (cur.left === void 0 || cur.right === void 0)) {
-        potentialParent = cur;
-      }
-      if (cur.left !== null) {
-        if (cur.left) queue.push(cur.left);
-      }
-      if (cur.right !== null) {
-        if (cur.right) queue.push(cur.right);
-      }
-    }
-    if (potentialParent) {
-      if (potentialParent.left === void 0) {
-        potentialParent.left = newNode;
-      } else if (potentialParent.right === void 0) {
-        potentialParent.right = newNode;
-      }
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
-      this._size++;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(k * n)
-   * Space Complexity: O(k)
-   *
-   * The `addMany` function takes in multiple keys or nodes or entries or raw values along with
-   * optional values, and adds them to a data structure while returning an array indicating whether
-   * each insertion was successful.
-   * @param keysNodesEntriesOrRaws - `keysNodesEntriesOrRaws` is an iterable that can contain a
-   * mix of keys, nodes, entries, or raw values. Each element in this iterable can be of type
-   * `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
-   * @param [values] - The `values` parameter in the `addMany` function is an optional parameter that
-   * accepts an iterable of values. These values correspond to the keys or nodes being added in the
-   * `keysNodesEntriesOrRaws` parameter. If provided, the function will iterate over the values and
-   * assign them
-   * @returns The `addMany` method returns an array of boolean values indicating whether each key,
-   * node, entry, or raw value was successfully added to the data structure. Each boolean value
-   * corresponds to the success of adding the corresponding key or value in the input iterable.
-   */
-  addMany(keysNodesEntriesOrRaws, values) {
-    const inserted = [];
-    let valuesIterator;
-    if (values) {
-      valuesIterator = values[Symbol.iterator]();
-    }
-    for (let keyNodeEntryOrRaw of keysNodesEntriesOrRaws) {
-      let value = void 0;
-      if (valuesIterator) {
-        const valueResult = valuesIterator.next();
-        if (!valueResult.done) {
-          value = valueResult.value;
-        }
-      }
-      if (this.isRaw(keyNodeEntryOrRaw)) keyNodeEntryOrRaw = this._toEntryFn(keyNodeEntryOrRaw);
-      inserted.push(this.add(keyNodeEntryOrRaw, value));
-    }
-    return inserted;
-  }
-  /**
-   * Time Complexity: O(k * n)
-   * Space Complexity: O(1)
-   *
-   * The `merge` function in TypeScript merges another binary tree into the current tree by adding all
-   * elements from the other tree.
-   * @param anotherTree - BinaryTree<K, V, R, MK, MV, MR>
-   */
-  merge(anotherTree) {
-    this.addMany(anotherTree, []);
-  }
-  /**
-   * Time Complexity: O(k * n)
-   * Space Complexity: O(1)
-   *
-   * The `refill` function clears the existing data structure and then adds new key-value pairs based
-   * on the provided input.
-   * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the `refill`
-   * method can accept an iterable containing a mix of `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` objects or `R`
-   * objects.
-   * @param [values] - The `values` parameter in the `refill` method is an optional parameter that
-   * accepts an iterable of values of type `V` or `undefined`.
-   */
-  refill(keysNodesEntriesOrRaws, values) {
-    this.clear();
-    this.addMany(keysNodesEntriesOrRaws, values);
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `delete` in TypeScript implements the deletion of a node in a binary tree and returns
-   * the deleted node along with information for tree balancing.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry
-   * - The `delete` method you provided is used to delete a node from a binary tree based on the key,
-   * node, entry or raw data. The method returns an array of
-   * `BinaryTreeDeleteResult` objects containing information about the deleted node and whether
-   * balancing is needed.
-   * @returns The `delete` method returns an array of `BinaryTreeDeleteResult` objects. Each object in
-   * the array contains information about the node that was deleted (`deleted`) and the node that may
-   * need to be balanced (`needBalanced`).
-   */
-  delete(keyNodeOrEntry) {
-    const deletedResult = [];
-    if (!this._root) return deletedResult;
-    const curr = this.getNode(keyNodeOrEntry);
-    if (!curr) return deletedResult;
-    const parent = curr?.parent;
-    let needBalanced;
-    let orgCurrent = curr;
-    if (!curr.left && !curr.right && !parent) {
-      this._setRoot(void 0);
-    } else if (curr.left) {
-      const leftSubTreeRightMost = this.getRightMost((node) => node, curr.left);
-      if (leftSubTreeRightMost) {
-        const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-        orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
-        if (parentOfLeftSubTreeMax) {
-          if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
-            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-          else parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
-          needBalanced = parentOfLeftSubTreeMax;
-        }
-      }
-    } else if (parent) {
-      const { familyPosition: fp } = curr;
-      if (fp === "LEFT" || fp === "ROOT_LEFT") {
-        parent.left = curr.right;
-      } else if (fp === "RIGHT" || fp === "ROOT_RIGHT") {
-        parent.right = curr.right;
-      }
-      needBalanced = parent;
-    } else {
-      this._setRoot(curr.right);
-      curr.right = void 0;
-    }
-    this._size = this._size - 1;
-    deletedResult.push({ deleted: orgCurrent, needBalanced });
-    if (this._isMapMode && orgCurrent) this._store.delete(orgCurrent.key);
-    return deletedResult;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(k + log n)
-   *
-   * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
-   * structure based on a given predicate or key, with options to return multiple results or just one.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
-   * `keyNodeEntryOrPredicate` parameter in the `search` function can accept three types of values:
-   * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function is a boolean flag that
-   * determines whether the search should stop after finding the first matching node. If `onlyOne` is
-   * set to `true`, the search will return as soon as a matching node is found. If `onlyOne` is
-   * @param {C} callback - The `callback` parameter in the `search` function is a callback function
-   * that will be called on each node that matches the search criteria. It is of type `C`, which
-   * extends `NodeCallback<BinaryTreeNode<K, V> | null>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `search` function is
-   * used to specify the node from which the search operation should begin. It represents the starting
-   * point in the binary tree where the search will be performed. If no specific `startNode` is
-   * provided, the search operation will start from the root
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `search` function
-   * specifies the type of iteration to be used when searching for nodes in a binary tree. It can have
-   * two possible values:
-   * @returns The `search` function returns an array of values that match the provided criteria based
-   * on the search algorithm implemented within the function.
-   */
-  search(keyNodeEntryOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    if (keyNodeEntryOrPredicate === void 0) return [];
-    if (keyNodeEntryOrPredicate === null) return [];
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    const predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
-    const ans = [];
-    if (iterationType === "RECURSIVE") {
-      const dfs = (cur) => {
-        if (predicate(cur)) {
-          ans.push(callback(cur));
-          if (onlyOne) return;
-        }
-        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-        if (this.isRealNode(cur.left)) dfs(cur.left);
-        if (this.isRealNode(cur.right)) dfs(cur.right);
-      };
-      dfs(startNode);
-    } else {
-      const stack = [startNode];
-      while (stack.length > 0) {
-        const cur = stack.pop();
-        if (this.isRealNode(cur)) {
-          if (predicate(cur)) {
-            ans.push(callback(cur));
-            if (onlyOne) return ans;
-          }
-          if (this.isRealNode(cur.left)) stack.push(cur.left);
-          if (this.isRealNode(cur.right)) stack.push(cur.right);
-        }
-      }
-    }
-    return ans;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(k + log n)
-   *
-   * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
-   * or predicate, with options for recursive or iterative traversal.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
-   * - The `getNodes` function you provided takes several parameters:
-   * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
-   * determines whether to return only the first node that matches the criteria specified by the
-   * `keyNodeEntryOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `getNodes` function is used to specify the starting point for traversing the binary tree. It
-   * represents the root node of the binary tree or the node from which the traversal should begin. If
-   * not provided, the default value is set to `this._root
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` function
-   * determines the type of iteration to be performed when traversing the nodes of a binary tree. It
-   * can have two possible values:
-   * @returns The `getNodes` function returns an array of nodes that satisfy the provided condition
-   * based on the input parameters and the iteration type specified.
-   */
-  getNodes(keyNodeEntryOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
-    return this.search(keyNodeEntryOrPredicate, onlyOne, (node) => node, startNode, iterationType);
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * The `getNode` function retrieves a node based on the provided key, node, entry, raw data, or
-   * predicate.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
-   * - The `keyNodeEntryOrPredicate` parameter in the `getNode` function can accept a key,
-   * node, entry, raw data, or a predicate function.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `getNode` function is used to specify the starting point for searching for a node in a binary
-   * tree. If no specific starting point is provided, the default value is set to `this._root`, which
-   * is typically the root node of the binary tree.
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `getNode` method is
-   * used to specify the type of iteration to be performed when searching for a node. It has a default
-   * value of `this.iterationType`, which means it will use the iteration type defined in the current
-   * context if no specific value is provided
-   * @returns The `getNode` function is returning the first node that matches the specified criteria,
-   * or `null` if no matching node is found.
-   */
-  getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType)[0];
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * This function overrides the `get` method to retrieve the value associated with a specified key,
-   * node, entry, raw data, or predicate in a data structure.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
-   * - The `keyNodeEntryOrPredicate` parameter in the `get` method can accept one of the
-   * following types:
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `get`
-   * method is used to specify the starting point for searching for a key or node in the binary tree.
-   * If no specific starting point is provided, the default starting point is the root of the binary
-   * tree (`this._root`).
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `get` method is used
-   * to specify the type of iteration to be performed when searching for a key in the binary tree. It
-   * is an optional parameter with a default value of `this.iterationType`, which means it will use the
-   * iteration type defined in the
-   * @returns The `get` method is returning the value associated with the specified key, node, entry,
-   * raw data, or predicate in the binary tree map. If the specified key or node is found in the tree,
-   * the method returns the corresponding value. If the key or node is not found, it returns
-   * `undefined`.
-   */
-  get(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    if (this._isMapMode) {
-      const key = this._extractKey(keyNodeEntryOrPredicate);
-      if (key === null || key === void 0) return;
-      return this._store.get(key);
-    }
-    return this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)?.value;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * The `has` function in TypeScript checks if a specified key, node, entry, raw data, or predicate
-   * exists in the data structure.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
-   * - The `keyNodeEntryOrPredicate` parameter in the `override has` method can accept one of
-   * the following types:
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `override` method is used to specify the starting point for the search operation within the data
-   * structure. It defaults to `this._root` if not provided explicitly.
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `override has` method
-   * is used to specify the type of iteration to be performed. It has a default value of
-   * `this.iterationType`, which means it will use the iteration type defined in the current context if
-   * no value is provided when calling the method.
-   * @returns The `override has` method is returning a boolean value. It checks if there are any nodes
-   * that match the provided key, node, entry, raw data, or predicate in the tree structure. If there
-   * are matching nodes, it returns `true`, indicating that the tree contains the specified element.
-   * Otherwise, it returns `false`.
-   */
-  has(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType).length > 0;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The clear function removes nodes and values in map mode.
-   */
-  clear() {
-    this._clearNodes();
-    if (this._isMapMode) this._clearValues();
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `isEmpty` function in TypeScript checks if a data structure has no elements and returns a
-   * boolean value.
-   * @returns The `isEmpty()` method is returning a boolean value, specifically `true` if the `_size`
-   * property is equal to 0, indicating that the data structure is empty, and `false` otherwise.
-   */
-  isEmpty() {
-    return this._size === 0;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * The function checks if a binary tree is perfectly balanced by comparing its minimum height with
-   * its height.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
-   * point for checking if the binary tree is perfectly balanced. It represents the root node of the
-   * binary tree or a specific node from which the balance check should begin.
-   * @returns The method `isPerfectlyBalanced` is returning a boolean value, which indicates whether
-   * the tree starting from the `startNode` node is perfectly balanced or not. The return value is
-   * determined by comparing the minimum height of the tree with the height of the tree. If the minimum
-   * height plus 1 is greater than or equal to the height of the tree, then it is considered perfectly
-   * balanced and
-   */
-  isPerfectlyBalanced(startNode = this._root) {
-    return this.getMinHeight(startNode) + 1 >= this.getHeight(startNode);
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * The function `isBST` in TypeScript checks if a binary search tree is valid using either recursive
-   * or iterative methods.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `isBST`
-   * function represents the starting point for checking whether a binary search tree (BST) is valid.
-   * It can be a node in the BST or a reference to the root of the BST. If no specific node is
-   * provided, the function will default to
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `isBST` function
-   * determines whether the function should use a recursive approach or an iterative approach to check
-   * if the binary search tree (BST) is valid.
-   * @returns The `isBST` method is returning a boolean value, which indicates whether the binary
-   * search tree (BST) represented by the given root node is a valid BST or not. The method checks if
-   * the tree satisfies the BST property, where for every node, all nodes in its left subtree have keys
-   * less than the node's key, and all nodes in its right subtree have keys greater than the node's
-   */
-  isBST(startNode = this._root, iterationType = this.iterationType) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return true;
-    if (iterationType === "RECURSIVE") {
-      const dfs = (cur, min, max) => {
-        if (!this.isRealNode(cur)) return true;
-        const numKey = Number(cur.key);
-        if (numKey <= min || numKey >= max) return false;
-        return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
-      };
-      const isStandardBST = dfs(startNode, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-      const isInverseBST = dfs(startNode, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
-      return isStandardBST || isInverseBST;
-    } else {
-      const checkBST = (checkMax = false) => {
-        const stack = [];
-        let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
-        let curr = startNode;
-        while (this.isRealNode(curr) || stack.length > 0) {
-          while (this.isRealNode(curr)) {
-            stack.push(curr);
-            curr = curr.left;
-          }
-          curr = stack.pop();
-          const numKey = Number(curr.key);
-          if (!this.isRealNode(curr) || !checkMax && prev >= numKey || checkMax && prev <= numKey) return false;
-          prev = numKey;
-          curr = curr.right;
-        }
-        return true;
-      };
-      const isStandardBST = checkBST(false), isInverseBST = checkBST(true);
-      return isStandardBST || isInverseBST;
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * The `getDepth` function calculates the depth between two nodes in a binary tree.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } dist - The `dist` parameter in the `getDepth`
-   * function represents the node or entry in a binary tree map, or a reference to a node in the tree.
-   * It is the target node for which you want to calculate the depth from the `startNode` node.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `getDepth` function represents the starting point from which you want to calculate the depth of a
-   * given node or entry in a binary tree. If no specific starting point is provided, the default value
-   * for `startNode` is set to the root of the binary
-   * @returns The `getDepth` method returns the depth of a given node `dist` relative to the
-   * `startNode` node in a binary tree. If the `dist` node is not found in the path to the `startNode`
-   * node, it returns the depth of the `dist` node from the root of the tree.
-   */
-  getDepth(dist, startNode = this._root) {
-    let distEnsured = this.ensureNode(dist);
-    const beginRootEnsured = this.ensureNode(startNode);
-    let depth = 0;
-    while (distEnsured?.parent) {
-      if (distEnsured === beginRootEnsured) {
-        return depth;
-      }
-      depth++;
-      distEnsured = distEnsured.parent;
-    }
-    return depth;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
-   * or iterative approach in TypeScript.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
-   * point from which the height of the binary tree will be calculated. It can be a node in the binary
-   * tree or a reference to the root of the tree. If not provided, it defaults to the root of the
-   * binary tree data structure.
-   * @param {IterationType} iterationType - The `iterationType` parameter is used to determine the type
-   * of iteration to be performed while calculating the height of the binary tree. It can have two
-   * possible values:
-   * @returns The `getHeight` method returns the height of the binary tree starting from the specified
-   * root node. The height is calculated based on the maximum depth of the tree, considering either a
-   * recursive approach or an iterative approach depending on the `iterationType` parameter.
-   */
-  getHeight(startNode = this._root, iterationType = this.iterationType) {
-    startNode = this.ensureNode(startNode);
-    if (!this.isRealNode(startNode)) return -1;
-    if (iterationType === "RECURSIVE") {
-      const _getMaxHeight = (cur) => {
-        if (!this.isRealNode(cur)) return -1;
-        const leftHeight = _getMaxHeight(cur.left);
-        const rightHeight = _getMaxHeight(cur.right);
-        return Math.max(leftHeight, rightHeight) + 1;
-      };
-      return _getMaxHeight(startNode);
-    } else {
-      const stack = [{ node: startNode, depth: 0 }];
-      let maxHeight = 0;
-      while (stack.length > 0) {
-        const { node, depth } = stack.pop();
-        if (this.isRealNode(node.left)) stack.push({ node: node.left, depth: depth + 1 });
-        if (this.isRealNode(node.right)) stack.push({ node: node.right, depth: depth + 1 });
-        maxHeight = Math.max(maxHeight, depth);
-      }
-      return maxHeight;
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * The `getMinHeight` function calculates the minimum height of a binary tree using either a
-   * recursive or iterative approach in TypeScript.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `getMinHeight` function represents the starting node from which the minimum height of the binary
-   * tree will be calculated. It is either a node in the binary tree or a reference to the root of the
-   * tree. If not provided, the default value is the root
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `getMinHeight` method
-   * specifies the type of iteration to use when calculating the minimum height of a binary tree. It
-   * can have two possible values:
-   * @returns The `getMinHeight` method returns the minimum height of the binary tree starting from the
-   * specified root node. The height is calculated based on the shortest path from the root node to a
-   * leaf node in the tree. The method uses either a recursive approach or an iterative approach (using
-   * a stack) based on the `iterationType` parameter.
-   */
-  getMinHeight(startNode = this._root, iterationType = this.iterationType) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return -1;
-    if (iterationType === "RECURSIVE") {
-      const _getMinHeight = (cur) => {
-        if (!this.isRealNode(cur)) return 0;
-        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return 0;
-        const leftMinHeight = _getMinHeight(cur.left);
-        const rightMinHeight = _getMinHeight(cur.right);
-        return Math.min(leftMinHeight, rightMinHeight) + 1;
-      };
-      return _getMinHeight(startNode);
-    } else {
-      const stack = [];
-      let node = startNode, last = null;
-      const depths = /* @__PURE__ */ new Map();
-      while (stack.length > 0 || node) {
-        if (this.isRealNode(node)) {
-          stack.push(node);
-          node = node.left;
-        } else {
-          node = stack[stack.length - 1];
-          if (!this.isRealNode(node.right) || last === node.right) {
-            node = stack.pop();
-            if (this.isRealNode(node)) {
-              const leftMinHeight = this.isRealNode(node.left) ? depths.get(node.left) : -1;
-              const rightMinHeight = this.isRealNode(node.right) ? depths.get(node.right) : -1;
-              depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
-              last = node;
-              node = null;
-            }
-          } else node = node.right;
-        }
-      }
-      return depths.get(startNode);
-    }
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function `getPathToRoot` in TypeScript retrieves the path from a given node to the root of a
-   * tree structure, applying a specified callback function along the way.
-   * @param {C} callback - The `callback` parameter is a function that is used to process each node in
-   * the path to the root. It is expected to be a function that takes a node as an argument and returns
-   * a value based on that node. The return type of the callback function is determined by the generic
-   * type `C
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } beginNode - The `beginNode` parameter in the
-   * `getPathToRoot` function can be either a key, a node, an entry, or any other value of type `R`.
-   * @param [isReverse=true] - The `isReverse` parameter in the `getPathToRoot` function determines
-   * whether the resulting path from the given `beginNode` to the root should be in reverse order or
-   * not. If `isReverse` is set to `true`, the path will be reversed before being returned. If `is
-   * @returns The function `getPathToRoot` returns an array of the return values of the callback
-   * function `callback` applied to each node in the path from the `beginNode` to the root node. The
-   * array is either in reverse order or in the original order based on the value of the `isReverse`
-   * parameter.
-   */
-  getPathToRoot(beginNode, callback = this._DEFAULT_NODE_CALLBACK, isReverse = false) {
-    const result = [];
-    let beginNodeEnsured = this.ensureNode(beginNode);
-    if (!beginNodeEnsured) return result;
-    while (beginNodeEnsured.parent) {
-      result.push(callback(beginNodeEnsured));
-      beginNodeEnsured = beginNodeEnsured.parent;
-    }
-    result.push(callback(beginNodeEnsured));
-    return isReverse ? result.reverse() : result;
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function `getLeftMost` retrieves the leftmost node in a binary tree using either recursive or
-   * tail-recursive iteration.
-   * @param {C} callback - The `callback` parameter is a function that will be called with the leftmost
-   * node of a binary tree or with `undefined` if the tree is empty. It is provided with a default
-   * value of `_DEFAULT_NODE_CALLBACK` if not specified.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `getLeftMost` function represents the starting point for finding the leftmost node in a binary
-   * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
-   * starting point is provided, the function will default
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `getLeftMost` function
-   * specifies the type of iteration to be used when traversing the binary tree nodes. It can have two
-   * possible values:
-   * @returns The `getLeftMost` function returns the result of the callback function `C` applied to the
-   * leftmost node in the binary tree starting from the `startNode` node. If the `startNode` node is
-   * `NIL`, it returns the result of the callback function applied to `undefined`. If the `startNode`
-   * node is not a real node, it returns the result of the callback
-   */
-  getLeftMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    if (this.isNIL(startNode)) return callback(void 0);
-    startNode = this.ensureNode(startNode);
-    if (!this.isRealNode(startNode)) return callback(startNode);
-    if (iterationType === "RECURSIVE") {
-      const dfs = (cur) => {
-        if (!this.isRealNode(cur.left)) return cur;
-        return dfs(cur.left);
-      };
-      return callback(dfs(startNode));
-    } else {
-      const dfs = trampoline((cur) => {
-        if (!this.isRealNode(cur.left)) return cur;
-        return dfs.cont(cur.left);
-      });
-      return callback(dfs(startNode));
-    }
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function `getRightMost` retrieves the rightmost node in a binary tree using either recursive
-   * or iterative traversal methods.
-   * @param {C} callback - The `callback` parameter is a function that will be called with the result
-   * of finding the rightmost node in a binary tree. It is of type `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`,
-   * which means it is a callback function that can accept either an optional binary tree node or null
-   * as
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `getRightMost` function represents the starting point for finding the rightmost node in a binary
-   * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
-   * starting point is provided, the function will default
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `getRightMost`
-   * function specifies the type of iteration to be used when traversing the binary tree nodes. It can
-   * have two possible values:
-   * @returns The `getRightMost` function returns the result of the callback function `C`, which is
-   * passed as a parameter to the function. The callback function is called with the rightmost node in
-   * the binary tree structure, determined based on the specified iteration type ('RECURSIVE' or
-   * other).
-   */
-  getRightMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    if (this.isNIL(startNode)) return callback(void 0);
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return callback(startNode);
-    if (iterationType === "RECURSIVE") {
-      const dfs = (cur) => {
-        if (!this.isRealNode(cur.right)) return cur;
-        return dfs(cur.right);
-      };
-      return callback(dfs(startNode));
-    } else {
-      const dfs = trampoline((cur) => {
-        if (!this.isRealNode(cur.right)) return cur;
-        return dfs.cont(cur.right);
-      });
-      return callback(dfs(startNode));
-    }
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function `getPredecessor` in TypeScript returns the predecessor node of a given node in a
-   * binary tree.
-   * @param {BinaryTreeNode<K, V>} node - The `getPredecessor` function you provided seems to be attempting to find the
-   * predecessor of a given node in a binary tree. However, there seems to be a logical issue in the
-   * while loop condition that might cause an infinite loop.
-   * @returns The `getPredecessor` function returns the predecessor node of the input `BinaryTreeNode<K, V>` parameter.
-   * If the left child of the input node exists, it traverses to the rightmost node of the left subtree
-   * to find the predecessor. If the left child does not exist, it returns the input node itself.
-   */
-  getPredecessor(node) {
-    if (this.isRealNode(node.left)) {
-      let predecessor = node.left;
-      while (!this.isRealNode(predecessor) || this.isRealNode(predecessor.right) && predecessor.right !== node) {
-        if (this.isRealNode(predecessor)) {
-          predecessor = predecessor.right;
-        }
-      }
-      return predecessor;
-    } else {
-      return node;
-    }
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function `getSuccessor` in TypeScript returns the next node in an in-order traversal of a
-   * binary tree.
-   * @param {K | BinaryTreeNode<K, V> | null} [x] - The `getSuccessor` function takes a parameter `x`, which can be of
-   * type `K`, `BinaryTreeNode<K, V>`, or `null`.
-   * @returns The `getSuccessor` function returns the successor node of the input node `x`. If `x` has
-   * a right child, the function returns the leftmost node in the right subtree of `x`. If `x` does not
-   * have a right child, the function traverses up the parent nodes until it finds a node that is not
-   * the right child of its parent, and returns that node
-   */
-  getSuccessor(x) {
-    x = this.ensureNode(x);
-    if (!this.isRealNode(x)) return void 0;
-    if (this.isRealNode(x.right)) {
-      return this.getLeftMost((node) => node, x.right);
-    }
-    let y = x.parent;
-    while (this.isRealNode(y) && x === y.right) {
-      x = y;
-      y = y.parent;
-    }
-    return y;
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The function performs a depth-first search on a binary tree structure based on the specified
-   * parameters.
-   * @param {C} callback - The `callback` parameter is a function that will be called for each node
-   * visited during the depth-first search. It should accept a `BinaryTreeNode` as an argument and
-   * return an optional node or null. The default value for this parameter is `_DEFAULT_NODE_CALLBACK`.
-   * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `dfs` function specifies
-   * the order in which the nodes are visited during a depth-first search traversal. The possible
-   * values for the `pattern` parameter are:
-   * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `dfs` function is a boolean flag
-   * that determines whether the depth-first search should stop after finding the first matching node
-   * or continue searching for all matching nodes. If `onlyOne` is set to `true`, the search will stop
-   * after finding the first matching node
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined}
-   * startNode - The `startNode` parameter in the `dfs` function can be one of the following types:
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `dfs` function
-   * specifies the type of iteration to be performed during the Depth-First Search traversal. It is
-   * used to determine the order in which nodes are visited during the traversal. The possible values
-   * for `iterationType` are typically defined as an enum or a
-   * @param [includeNull=false] - The `includeNull` parameter in the `dfs` function determines whether
-   * null nodes should be included in the depth-first search traversal. If `includeNull` is set to
-   * `true`, null nodes will be included in the traversal process. If it is set to `false`, null nodes
-   * will be skipped
-   * @returns The `dfs` method is returning an array of the return type of the callback function `C`.
-   */
-  dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    return this._dfs(callback, pattern, onlyOne, startNode, iterationType, includeNull);
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The `bfs` function performs a breadth-first search traversal on a binary tree or binary search
-   * tree, executing a specified callback function on each node visited.
-   * @param {C} callback - The `callback` parameter in the `bfs` function is a function that will be
-   * called on each node visited during the breadth-first search traversal. It is a generic type `C`
-   * that extends the `NodeCallback` type, which takes a parameter of type `BinaryTreeNode<K, V>` or `null`.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `bfs`
-   * function represents the starting point for the breadth-first search traversal in a binary tree. It
-   * can be specified as a key, node, or entry in the binary tree structure. If not provided, the
-   * default value is the root node of the binary
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `bfs` function
-   * determines the type of iteration to be performed on the binary tree nodes. It can have two
-   * possible values:
-   * @param [includeNull=false] - The `includeNull` parameter in the `bfs` function determines whether
-   * to include `null` values in the breadth-first search traversal of a binary tree. If `includeNull`
-   * is set to `true`, the traversal will include `null` values for nodes that do not have children
-   * (left
-   * @returns The `bfs` function returns an array of values that are the result of applying the
-   * provided callback function to each node in the binary tree in a breadth-first search manner.
-   */
-  bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    const ans = [];
-    if (iterationType === "RECURSIVE") {
-      const queue = new Queue([
-        startNode
-      ]);
-      const dfs = (level) => {
-        if (queue.length === 0) return;
-        const current = queue.shift();
-        ans.push(callback(current));
-        if (includeNull) {
-          if (current && this.isRealNodeOrNull(current.left)) queue.push(current.left);
-          if (current && this.isRealNodeOrNull(current.right)) queue.push(current.right);
-        } else {
-          if (this.isRealNode(current.left)) queue.push(current.left);
-          if (this.isRealNode(current.right)) queue.push(current.right);
-        }
-        dfs(level + 1);
-      };
-      dfs(0);
-    } else {
-      const queue = new Queue([startNode]);
-      while (queue.length > 0) {
-        const levelSize = queue.length;
-        for (let i = 0; i < levelSize; i++) {
-          const current = queue.shift();
-          ans.push(callback(current));
-          if (includeNull) {
-            if (current && this.isRealNodeOrNull(current.left)) queue.push(current.left);
-            if (current && this.isRealNodeOrNull(current.right)) queue.push(current.right);
-          } else {
-            if (this.isRealNode(current.left)) queue.push(current.left);
-            if (this.isRealNode(current.right)) queue.push(current.right);
-          }
-        }
-      }
-    }
-    return ans;
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The `leaves` function in TypeScript returns an array of values from leaf nodes in a binary tree
-   * structure based on a specified callback and iteration type.
-   * @param {C} callback - The `callback` parameter is a function that will be called on each leaf node
-   * in the binary tree. It is optional and defaults to a default callback function if not provided.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `leaves`
-   * method is used to specify the starting point for finding and processing the leaves of a binary
-   * tree. It can be provided as either a key, a node, or an entry in the binary tree structure. If not
-   * explicitly provided, the default value
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `leaves` method
-   * specifies the type of iteration to be performed when collecting the leaves of a binary tree. It
-   * can have two possible values:
-   * @returns The `leaves` method returns an array of values that are the result of applying the
-   * provided callback function to each leaf node in the binary tree.
-   */
-  leaves(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    startNode = this.ensureNode(startNode);
-    const leaves = [];
-    if (!this.isRealNode(startNode)) return [];
-    if (iterationType === "RECURSIVE") {
-      const dfs = (cur) => {
-        if (this.isLeaf(cur)) {
-          leaves.push(callback(cur));
-        }
-        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-        if (this.isRealNode(cur.left)) dfs(cur.left);
-        if (this.isRealNode(cur.right)) dfs(cur.right);
-      };
-      dfs(startNode);
-    } else {
-      const queue = new Queue([startNode]);
-      while (queue.length > 0) {
-        const cur = queue.shift();
-        if (this.isRealNode(cur)) {
-          if (this.isLeaf(cur)) {
-            leaves.push(callback(cur));
-          }
-          if (this.isRealNode(cur.left)) queue.push(cur.left);
-          if (this.isRealNode(cur.right)) queue.push(cur.right);
-        }
-      }
-    }
-    return leaves;
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The `listLevels` function in TypeScript generates a list of nodes at each level of a binary tree,
-   * using either recursive or iterative traversal based on the specified iteration type.
-   * @param {C} callback - The `callback` parameter is a function that will be applied to each node in
-   * the binary tree during the traversal. It is used to process each node and determine what
-   * information to include in the output for each level of the tree.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `listLevels` function represents the starting point for traversing the binary tree. It can be
-   * either a key, a node, or an entry in the binary tree. If not provided, the default value is the
-   * root of the binary tree.
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `listLevels` function
-   * determines the type of iteration to be performed on the binary tree nodes. It can have two
-   * possible values:
-   * @param [includeNull=false] - The `includeNull` parameter in the `listLevels` method determines
-   * whether or not to include null nodes in the traversal of the binary tree. If `includeNull` is set
-   * to `true`, the traversal will include null nodes in the levels of the tree. If set to `false`,
-   * null
-   * @returns The `listLevels` method returns an array of arrays, where each inner array represents a
-   * level in a binary tree. Each inner array contains the return value of the provided callback
-   * function applied to the nodes at that level.
-   */
-  listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
-    startNode = this.ensureNode(startNode);
-    const levelsNodes = [];
-    if (!startNode) return levelsNodes;
-    if (iterationType === "RECURSIVE") {
-      const _recursive = (node, level) => {
-        if (!levelsNodes[level]) levelsNodes[level] = [];
-        levelsNodes[level].push(callback(node));
-        if (includeNull) {
-          if (node && this.isRealNodeOrNull(node.left)) _recursive(node.left, level + 1);
-          if (node && this.isRealNodeOrNull(node.right)) _recursive(node.right, level + 1);
-        } else {
-          if (node && node.left) _recursive(node.left, level + 1);
-          if (node && node.right) _recursive(node.right, level + 1);
-        }
-      };
-      _recursive(startNode, 0);
-    } else {
-      const stack = [[startNode, 0]];
-      while (stack.length > 0) {
-        const head = stack.pop();
-        const [node, level] = head;
-        if (!levelsNodes[level]) levelsNodes[level] = [];
-        levelsNodes[level].push(callback(node));
-        if (includeNull) {
-          if (node && this.isRealNodeOrNull(node.right)) stack.push([node.right, level + 1]);
-          if (node && this.isRealNodeOrNull(node.left)) stack.push([node.left, level + 1]);
-        } else {
-          if (node && node.right) stack.push([node.right, level + 1]);
-          if (node && node.left) stack.push([node.left, level + 1]);
-        }
-      }
-    }
-    return levelsNodes;
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The `morris` function in TypeScript performs a Depth-First Search traversal on a binary tree using
-   * Morris Traversal algorithm with different order patterns.
-   * @param {C} callback - The `callback` parameter in the `morris` function is a function that will be
-   * called on each node in the binary tree during the traversal. It is of type `C`, which extends the
-   * `NodeCallback<BinaryTreeNode<K, V> | null>` type. The default value for `callback` is `this._DEFAULT
-   * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function specifies
-   * the type of Depth-First Search (DFS) order pattern to traverse the binary tree. The possible
-   * values for the `pattern` parameter are:
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `morris`
-   * function is the starting point for the Morris traversal algorithm. It represents the root node of
-   * the binary tree or the node from which the traversal should begin. It can be provided as either a
-   * key, a node, an entry, or a reference
-   * @returns The `morris` function is returning an array of values that are the result of applying the
-   * provided callback function to each node in the binary tree in the specified order pattern (IN,
-   * PRE, or POST).
-   */
-  morris(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", startNode = this._root) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    const ans = [];
-    let cur = startNode;
-    const _reverseEdge = (node) => {
-      let pre = null;
-      let next = null;
-      while (node) {
-        next = node.right;
-        node.right = pre;
-        pre = node;
-        node = next;
-      }
-      return pre;
-    };
-    const _printEdge = (node) => {
-      const tail = _reverseEdge(node);
-      let cur2 = tail;
-      while (cur2) {
-        ans.push(callback(cur2));
-        cur2 = cur2.right;
-      }
-      _reverseEdge(tail);
-    };
-    switch (pattern) {
-      case "IN":
-        while (cur) {
-          if (cur.left) {
-            const predecessor = this.getPredecessor(cur);
-            if (!predecessor.right) {
-              predecessor.right = cur;
-              cur = cur.left;
-              continue;
-            } else {
-              predecessor.right = null;
-            }
-          }
-          ans.push(callback(cur));
-          cur = cur.right;
-        }
-        break;
-      case "PRE":
-        while (cur) {
-          if (cur.left) {
-            const predecessor = this.getPredecessor(cur);
-            if (!predecessor.right) {
-              predecessor.right = cur;
-              ans.push(callback(cur));
-              cur = cur.left;
-              continue;
-            } else {
-              predecessor.right = null;
-            }
-          } else {
-            ans.push(callback(cur));
-          }
-          cur = cur.right;
-        }
-        break;
-      case "POST":
-        while (cur) {
-          if (cur.left) {
-            const predecessor = this.getPredecessor(cur);
-            if (predecessor.right === null) {
-              predecessor.right = cur;
-              cur = cur.left;
-              continue;
-            } else {
-              predecessor.right = null;
-              _printEdge(cur.left);
-            }
-          }
-          cur = cur.right;
-        }
-        _printEdge(startNode);
-        break;
-    }
-    return ans;
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The `clone` function creates a deep copy of a tree structure by traversing it using breadth-first
-   * search.
-   * @returns The `clone()` method is returning a cloned copy of the tree with the same structure and
-   * values as the original tree. The method creates a new tree, iterates over the nodes of the
-   * original tree using breadth-first search (bfs), and adds the nodes to the new tree. If a node in
-   * the original tree is null, a null node is added to the cloned tree. If a node
-   */
-  clone() {
-    const cloned = this.createTree();
-    this._clone(cloned);
-    return cloned;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `filter` function iterates over key-value pairs in a tree data structure and creates a new
-   * tree with elements that satisfy a given predicate.
-   * @param predicate - The `predicate` parameter in the `filter` method is a function that will be
-   * called with four arguments: the `value` of the current entry, the `key` of the current entry, the
-   * `index` of the current entry in the iteration, and the reference to the tree itself (`
-   * @param {any} [thisArg] - The `thisArg` parameter in the `filter` method allows you to specify the
-   * value of `this` that should be used when executing the `predicate` function. This is useful when
-   * the `predicate` function relies on the context of a specific object or value. By providing a
-   * `thisArg
-   * @returns The `filter` method is returning a new tree that contains entries that pass the provided
-   * predicate function.
-   */
-  filter(predicate, thisArg) {
-    const newTree = this.createTree();
-    let index = 0;
-    for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index++, this)) {
-        newTree.add([key, value]);
-      }
-    }
-    return newTree;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `map` function in TypeScript creates a new BinaryTree by applying a callback function to each
-   * entry in the original BinaryTree.
-   * @param callback - A function that will be called for each entry in the current binary tree. It
-   * takes the key, value (which can be undefined), and an array containing the mapped key and value as
-   * arguments.
-   * @param [options] - The `options` parameter in the `map` method is of type `BinaryTreeOptions<MK,
-   * MV, MR>`. It is an optional parameter that allows you to specify additional options for the binary
-   * tree being created during the mapping process. These options could include things like custom
-   * comparators, initial
-   * @param {any} [thisArg] - The `thisArg` parameter in the `map` method is used to specify the value
-   * of `this` when executing the `callback` function. It allows you to set the context (value of
-   * `this`) within the callback function. If `thisArg` is provided, it will be passed
-   * @returns The `map` function is returning a new `BinaryTree` instance filled with entries that are
-   * the result of applying the provided `callback` function to each entry in the original tree.
-   */
-  map(callback, options, thisArg) {
-    const newTree = new _BinaryTree([], options);
-    let index = 0;
-    for (const [key, value] of this) {
-      newTree.add(callback.call(thisArg, key, value, index++, this));
-    }
-    return newTree;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function `toVisual` in TypeScript overrides the visual representation of a binary tree with
-   * customizable options for displaying undefined, null, and sentinel nodes.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `toVisual` method is used to specify the starting point for visualizing the binary tree structure.
-   * It can be a node, key, entry, or the root of the tree. If no specific starting point is provided,
-   * the default is set to the root
-   * @param {BinaryTreePrintOptions} [options] - The `options` parameter in the `toVisual` method is an
-   * object that contains the following properties:
-   * @returns The `override toVisual` method returns a string that represents the visual display of the
-   * binary tree based on the provided options for showing undefined, null, and Red-Black NIL nodes.
-   * The method constructs the visual representation by calling the `_displayAux` method and appending
-   * the lines to the output string. The final output string contains the visual representation of the
-   * binary tree with the specified options.
-   */
-  toVisual(startNode = this._root, options) {
-    const opts = { isShowUndefined: false, isShowNull: true, isShowRedBlackNIL: false, ...options };
-    startNode = this.ensureNode(startNode);
-    let output = "";
-    if (!startNode) return output;
-    if (opts.isShowUndefined) output += `U for undefined
-`;
-    if (opts.isShowNull) output += `N for null
-`;
-    if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)
-`;
-    const display = (root) => {
-      const [lines] = this._displayAux(root, opts);
-      let paragraph = "";
-      for (const line of lines) {
-        paragraph += line + "\n";
-      }
-      output += paragraph;
-    };
-    display(startNode);
-    return output;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function `print` in TypeScript overrides the default print behavior to log a visual
-   * representation of the binary tree to the console.
-   * @param {BinaryTreePrintOptions} [options] - The `options` parameter is used to specify the
-   * printing options for the binary tree. It is an optional parameter that allows you to customize how
-   * the binary tree is printed, such as choosing between different traversal orders or formatting
-   * options.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
-   * `override print` method is used to specify the starting point for printing the binary tree. It can
-   * be either a key, a node, an entry, or the root of the tree. If no specific starting point is
-   * provided, the default value is set to
-   */
-  print(options, startNode = this._root) {
-    console.log(this.toVisual(startNode, options));
-  }
-  _clone(cloned) {
-    this.bfs(
-      (node) => {
-        if (node === null) cloned.add(null);
-        else {
-          if (this._isMapMode) cloned.add([node.key, this._store.get(node.key)]);
-          else cloned.add([node.key, node.value]);
-        }
-      },
-      this._root,
-      this.iterationType,
-      true
-    );
-    if (this._isMapMode) cloned._store = this._store;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
-   * or returns null.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The
-   * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeOrEntry`, which
-   * can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. This parameter represents either a key, a
-   * node, an entry
-   * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
-   * an optional parameter of type `V`. It represents the value associated with the key in the node
-   * being created. If a `value` is provided, it will be used when creating the node. If
-   * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
-   * (`BinaryTreeNode<K, V> | null | undefined`) based on the input parameters provided. The function checks the type of the
-   * input parameter (`keyNodeOrEntry`) and processes it accordingly to return a node or null
-   * value.
-   */
-  _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
-    if (keyNodeOrEntry === void 0) return [void 0, void 0];
-    if (keyNodeOrEntry === null) return [null, void 0];
-    if (this.isNode(keyNodeOrEntry)) return [keyNodeOrEntry, value];
-    if (this.isEntry(keyNodeOrEntry)) {
-      const [key, entryValue] = keyNodeOrEntry;
-      if (key === void 0) return [void 0, void 0];
-      else if (key === null) return [null, void 0];
-      const finalValue = value ?? entryValue;
-      return [this.createNode(key, finalValue), finalValue];
-    }
-    return [this.createNode(keyNodeOrEntry, value), value];
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The `_dfs` function performs a depth-first search traversal on a binary tree, with customizable
-   * options for traversal order and node processing.
-   * @param {C} callback - The `callback` parameter in the `_dfs` method is a function that will be
-   * called on each node visited during the depth-first search traversal. It is a generic type `C` that
-   * extends `NodeCallback<BinaryTreeNode<K, V> | null>`. The default value for `callback`
-   * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `_dfs` method specifies the
-   * order in which the nodes are visited during a depth-first search traversal. It can have one of the
-   * following values:
-   * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `_dfs` method is a boolean flag
-   * that determines whether the traversal should stop after processing a single node. If `onlyOne` is
-   * set to `true`, the traversal will return as soon as a single node is processed. If it is set to
-   * `false
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined}
-   * startNode - The `startNode` parameter in the `_dfs` method is used to specify the starting node
-   * for the depth-first search traversal. It can be provided in different forms:
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `_dfs` method
-   * specifies whether the traversal should be done recursively or iteratively. It can have two
-   * possible values:
-   * @param [includeNull=false] - The `includeNull` parameter in the `_dfs` method determines whether
-   * null nodes should be included in the traversal process. If `includeNull` is set to `true`, the
-   * method will consider null nodes as valid nodes to visit or process. If `includeNull` is set to
-   * `false`,
-   * @param shouldVisitLeft - The `shouldVisitLeft` parameter in the `_dfs` method is a function that
-   * determines whether the left child of a node should be visited during the Depth-First Search
-   * traversal. By default, it checks if the node is not null or undefined before visiting the left
-   * child. You can customize this behavior
-   * @param shouldVisitRight - The `shouldVisitRight` parameter in the `_dfs` method is a function that
-   * determines whether to visit the right child node of the current node during a depth-first search
-   * traversal. The default implementation of this function checks if the node is not null or undefined
-   * before deciding to visit it.
-   * @param shouldVisitRoot - The `shouldVisitRoot` parameter in the `_dfs` method is a function that
-   * determines whether a given node should be visited during the depth-first search traversal. The
-   * function takes a node as an argument and returns a boolean value indicating whether the node
-   * should be visited.
-   * @param shouldProcessRoot - The `shouldProcessRoot` parameter in the `_dfs` method is a function
-   * that determines whether the root node should be processed during the Depth-First Search traversal.
-   * It takes a node (BinaryTreeNode<K, V> | null | undefined) as input and returns a boolean value. If
-   * the function
-   * @returns The `_dfs` method returns an array of the return type of the provided callback function
-   * `C`.
-   */
-  _dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = (node) => !!node, shouldVisitRight = (node) => !!node, shouldVisitRoot = (node) => {
-    if (includeNull) return this.isRealNodeOrNull(node);
-    return this.isRealNode(node);
-  }, shouldProcessRoot = (node) => this.isRealNodeOrNull(node)) {
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    const ans = [];
-    if (iterationType === "RECURSIVE") {
-      const dfs = (node) => {
-        if (!shouldVisitRoot(node)) return;
-        const visitLeft = () => {
-          if (shouldVisitLeft(node) && node?.left !== void 0) dfs(node?.left);
-        };
-        const visitRight = () => {
-          if (shouldVisitRight(node) && node?.right !== void 0) dfs(node?.right);
-        };
-        switch (pattern) {
-          case "IN":
-            visitLeft();
-            if (shouldProcessRoot(node)) {
-              ans.push(callback(node));
-              if (onlyOne) return;
-            }
-            visitRight();
-            break;
-          case "PRE":
-            if (shouldProcessRoot(node)) {
-              ans.push(callback(node));
-              if (onlyOne) return;
-            }
-            visitLeft();
-            visitRight();
-            break;
-          case "POST":
-            visitLeft();
-            visitRight();
-            if (shouldProcessRoot(node)) {
-              ans.push(callback(node));
-              if (onlyOne) return;
-            }
-            break;
-        }
-      };
-      dfs(startNode);
-    } else {
-      const stack = [{ opt: 0 /* VISIT */, node: startNode }];
-      const pushLeft = (cur) => {
-        if (shouldVisitLeft(cur.node)) stack.push({ opt: 0 /* VISIT */, node: cur.node?.left });
-      };
-      const pushRight = (cur) => {
-        if (shouldVisitRight(cur.node)) stack.push({ opt: 0 /* VISIT */, node: cur.node?.right });
-      };
-      const pushRoot = (cur) => {
-        if (shouldVisitRoot(cur.node)) stack.push({ opt: 1 /* PROCESS */, node: cur.node });
-      };
-      while (stack.length > 0) {
-        const cur = stack.pop();
-        if (cur === void 0) continue;
-        if (!shouldVisitRoot(cur.node)) continue;
-        if (cur.opt === 1 /* PROCESS */) {
-          if (shouldProcessRoot(cur.node) && cur.node !== void 0) {
-            ans.push(callback(cur.node));
-            if (onlyOne) return ans;
-          }
-        } else {
-          switch (pattern) {
-            case "IN":
-              pushRight(cur);
-              pushRoot(cur);
-              pushLeft(cur);
-              break;
-            case "PRE":
-              pushRight(cur);
-              pushLeft(cur);
-              pushRoot(cur);
-              break;
-            case "POST":
-              pushRoot(cur);
-              pushRight(cur);
-              pushLeft(cur);
-              break;
-          }
-        }
-      }
-    }
-    return ans;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `_getIterator` returns an iterable iterator for a binary tree data structure, either
-   * using an iterative approach or a recursive approach based on the specified iteration type.
-   * @param node - The `node` parameter in the `_getIterator` method represents the current node being
-   * processed during iteration. It is initially set to the root node of the data structure (or the
-   * node passed as an argument), and then it is traversed through the data structure based on the
-   * iteration type specified (`ITER
-   * @returns The `_getIterator` method returns an IterableIterator containing key-value pairs of nodes
-   * in a binary tree structure. The method uses an iterative approach to traverse the tree based on
-   * the `iterationType` property. If the `iterationType` is set to 'ITERATIVE', the method uses a
-   * stack to perform an in-order traversal of the tree. If the `iterationType` is not 'ITERATIVE
-   */
-  *_getIterator(node = this._root) {
-    if (!node) return;
-    if (this.iterationType === "ITERATIVE") {
-      const stack = [];
-      let current = node;
-      while (current || stack.length > 0) {
-        while (this.isRealNode(current)) {
-          stack.push(current);
-          current = current.left;
-        }
-        current = stack.pop();
-        if (this.isRealNode(current)) {
-          if (this._isMapMode) yield [current.key, this._store.get(current.key)];
-          else yield [current.key, current.value];
-          current = current.right;
-        }
-      }
-    } else {
-      if (node.left && this.isRealNode(node)) {
-        yield* this[Symbol.iterator](node.left);
-      }
-      if (this._isMapMode) yield [node.key, this._store.get(node.key)];
-      else yield [node.key, node.value];
-      if (node.right && this.isRealNode(node)) {
-        yield* this[Symbol.iterator](node.right);
-      }
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function `_displayAux` in TypeScript is responsible for generating the display layout of nodes
-   * in a binary tree based on specified options.
-   * @param node - The `node` parameter in the `_displayAux` function represents a node in a binary
-   * tree. It can be either a valid node containing a key or a special type of node like null,
-   * undefined, or a Red-Black tree NIL node. The function checks the type of the node and its
-   * @param {BinaryTreePrintOptions} options - The `options` parameter in the `_displayAux` function
-   * contains the following properties:
-   * @returns The `_displayAux` function returns a `NodeDisplayLayout`, which is an array containing
-   * information about how to display a node in a binary tree. The `NodeDisplayLayout` consists of four
-   * elements:
-   */
-  _displayAux(node, options) {
-    const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
-    const emptyDisplayLayout = [["\u2500"], 1, 0, 0];
-    if (node === null && !isShowNull) {
-      return emptyDisplayLayout;
-    } else if (node === void 0 && !isShowUndefined) {
-      return emptyDisplayLayout;
-    } else if (this.isNIL(node) && !isShowRedBlackNIL) {
-      return emptyDisplayLayout;
-    } else if (node !== null && node !== void 0) {
-      const key = node.key, line = this.isNIL(node) ? "S" : String(key), width = line.length;
-      return _buildNodeDisplay(
-        line,
-        width,
-        this._displayAux(node.left, options),
-        this._displayAux(node.right, options)
-      );
-    } else {
-      const line = node === void 0 ? "U" : "N", width = line.length;
-      return _buildNodeDisplay(line, width, [[""], 1, 0, 0], [[""], 1, 0, 0]);
-    }
-    function _buildNodeDisplay(line, width, left, right) {
-      const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
-      const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
-      const firstLine = " ".repeat(Math.max(0, leftMiddle + 1)) + "_".repeat(Math.max(0, leftWidth - leftMiddle - 1)) + line + "_".repeat(Math.max(0, rightMiddle)) + " ".repeat(Math.max(0, rightWidth - rightMiddle));
-      const secondLine = (leftHeight > 0 ? " ".repeat(leftMiddle) + "/" + " ".repeat(leftWidth - leftMiddle - 1) : " ".repeat(leftWidth)) + " ".repeat(width) + (rightHeight > 0 ? " ".repeat(rightMiddle) + "\\" + " ".repeat(rightWidth - rightMiddle - 1) : " ".repeat(rightWidth));
-      const mergedLines = [firstLine, secondLine];
-      for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
-        const leftLine = i < leftHeight ? leftLines[i] : " ".repeat(leftWidth);
-        const rightLine = i < rightHeight ? rightLines[i] : " ".repeat(rightWidth);
-        mergedLines.push(leftLine + " ".repeat(width) + rightLine);
-      }
-      return [
-        mergedLines,
-        leftWidth + width + rightWidth,
-        Math.max(leftHeight, rightHeight) + 2,
-        leftWidth + Math.floor(width / 2)
-      ];
-    }
-  }
-  _DEFAULT_NODE_CALLBACK = (node) => node ? node.key : void 0;
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The _swapProperties function swaps key and value properties between two nodes in a binary tree.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } srcNode - The `srcNode` parameter in the
-   * `_swapProperties` method can be either a BTNRep object containing key and value
-   * properties, or it can be of type R.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } destNode - The `destNode` parameter in the
-   * `_swapProperties` method represents the node or entry where the properties will be swapped with
-   * the `srcNode`. It can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. The method ensures that
-   * both `srcNode
-   * @returns The `_swapProperties` method returns either the `destNode` with its key and value swapped
-   * with the `srcNode`, or `undefined` if either `srcNode` or `destNode` is falsy.
-   */
-  _swapProperties(srcNode, destNode) {
-    srcNode = this.ensureNode(srcNode);
-    destNode = this.ensureNode(destNode);
-    if (srcNode && destNode) {
-      const { key, value } = destNode;
-      const tempNode = this.createNode(key, value);
-      if (tempNode) {
-        destNode.key = srcNode.key;
-        if (!this._isMapMode) destNode.value = srcNode.value;
-        srcNode.key = tempNode.key;
-        if (!this._isMapMode) srcNode.value = tempNode.value;
-      }
-      return destNode;
-    }
-    return void 0;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The _replaceNode function replaces an old node with a new node in a binary tree structure.
-   * @param {BinaryTreeNode<K, V>} oldNode - The `oldNode` parameter represents the node that you want to replace in a
-   * tree data structure.
-   * @param {BinaryTreeNode<K, V>} newNode - The `newNode` parameter in the `_replaceNode` function represents the node
-   * that will replace the `oldNode` in a tree data structure. This function is responsible for
-   * updating the parent, left child, right child, and root (if necessary) references when replacing a
-   * node in the tree.
-   * @returns The method `_replaceNode` is returning the `newNode` that was passed as a parameter after
-   * replacing the `oldNode` with it in the binary tree structure.
-   */
-  _replaceNode(oldNode, newNode) {
-    if (oldNode.parent) {
-      if (oldNode.parent.left === oldNode) {
-        oldNode.parent.left = newNode;
-      } else if (oldNode.parent.right === oldNode) {
-        oldNode.parent.right = newNode;
-      }
-    }
-    newNode.left = oldNode.left;
-    newNode.right = oldNode.right;
-    newNode.parent = oldNode.parent;
-    if (this._root === oldNode) {
-      this._setRoot(newNode);
-    }
-    return newNode;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function _setRoot sets the root node of a data structure while updating the parent reference
-   * of the previous root node.
-   * @param v - The parameter `v` in the `_setRoot` method is of type `BinaryTreeNode<K, V> | null | undefined`, which means
-   * it can either be an optional `BinaryTreeNode<K, V>` type or `null`.
-   */
-  _setRoot(v) {
-    if (v) {
-      v.parent = void 0;
-    }
-    this._root = v;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `_ensurePredicate` in TypeScript ensures that the input is converted into a valid
-   * predicate function for a binary tree node.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
-   * `_ensurePredicate` method in the provided code snippet is responsible for ensuring that the input
-   * parameter `keyNodeEntryOrPredicate` is transformed into a valid predicate function that can be
-   * used for filtering nodes in a binary tree.
-   * @returns A NodePredicate<BinaryTreeNode<K, V>> function is being returned.
-   */
-  _ensurePredicate(keyNodeEntryOrPredicate) {
-    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0)
-      return (node) => node ? false : false;
-    if (this._isPredicate(keyNodeEntryOrPredicate)) return keyNodeEntryOrPredicate;
-    if (this.isRealNode(keyNodeEntryOrPredicate))
-      return (node) => node === keyNodeEntryOrPredicate;
-    if (this.isEntry(keyNodeEntryOrPredicate)) {
-      const [key] = keyNodeEntryOrPredicate;
-      return (node) => {
-        if (!node) return false;
-        return node.key === key;
-      };
-    }
-    return (node) => {
-      if (!node) return false;
-      return node.key === keyNodeEntryOrPredicate;
-    };
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `_isPredicate` checks if a given parameter is a function.
-   * @param {any} p - The parameter `p` is a variable of type `any`, which means it can hold any type
-   * of value. In this context, the function `_isPredicate` is checking if `p` is a function that
-   * satisfies the type `NodePredicate<BinaryTreeNode<K, V>>`.
-   * @returns The function is checking if the input `p` is a function and returning a boolean value
-   * based on that check. If `p` is a function, it will return `true`, indicating that `p` is a
-   * predicate function for a binary tree node. If `p` is not a function, it will return `false`.
-   */
-  _isPredicate(p) {
-    return typeof p === "function";
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `_extractKey` in TypeScript returns the key from a given input, which can be a node,
-   * entry, raw data, or null/undefined.
-   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `_extractKey` method you provided is a
-   * TypeScript method that takes in a parameter `keyNodeOrEntry` of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `,
-   * where `BTNRep` is a generic type with keys `K`, `V`, and `BinaryTreeNode<K, V>`, and `
-   * @returns The `_extractKey` method returns the key value extracted from the `keyNodeOrEntry`
-   * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
-   * the conditions checked in the method.
-   */
-  _extractKey(keyNodeOrEntry) {
-    if (keyNodeOrEntry === null) return null;
-    if (keyNodeOrEntry === void 0) return;
-    if (keyNodeOrEntry === this._NIL) return;
-    if (this.isNode(keyNodeOrEntry)) return keyNodeOrEntry.key;
-    if (this.isEntry(keyNodeOrEntry)) return keyNodeOrEntry[0];
-    return keyNodeOrEntry;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `_setValue` sets a value in a store based on a key, handling cases where the key or
-   * value is null or undefined.
-   * @param {K | null | undefined} key - The `key` parameter can be of type `K`, `null`, or
-   * `undefined`.
-   * @param {V | undefined} value - The `value` parameter in the `_setValue` method can be of type `V`
-   * or `undefined`.
-   * @returns The method `_setValue` returns `false` if either the `key` is `null` or `undefined`, or
-   * if the `value` is `undefined`. Otherwise, it returns the result of calling the `set` method on the
-   * `_store` object with the `key` and `value` arguments.
-   */
-  _setValue(key, value) {
-    if (key === null || key === void 0) return false;
-    if (value === void 0) return false;
-    return this._store.set(key, value);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The _clearNodes function sets the root node to undefined and resets the size to 0.
-   */
-  _clearNodes() {
-    this._setRoot(void 0);
-    this._size = 0;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The _clearValues function clears all values stored in the _store object.
-   */
-  _clearValues() {
-    this._store.clear();
-  }
-};
-
-// src/data-structures/binary-tree/bst.ts
-var BSTNode = class extends BinaryTreeNode {
-  parent = void 0;
-  /**
-   * This TypeScript constructor function initializes an instance with a key and an optional value.
-   * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
-   * within a data structure. It serves as a reference or identifier for accessing or manipulating the
-   * associated value.
-   * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
-   * have to be provided when creating an instance of the class. If a value is not provided, it will
-   * default to `undefined`.
-   */
-  constructor(key, value) {
-    super(key, value);
-  }
-  _left = void 0;
-  get left() {
-    return this._left;
-  }
-  set left(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._left = v;
-  }
-  _right = void 0;
-  get right() {
-    return this._right;
-  }
-  set right(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._right = v;
-  }
-};
-var BST = class _BST extends BinaryTree {
-  /**
-   * This TypeScript constructor initializes a binary search tree with optional options and adds
-   * elements if provided.
-   * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain elements of type `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It is used to
-   * initialize the binary search tree with keys, nodes, entries, or raw data.
-   * @param [options] - The `options` parameter is an optional object that can contain the following
-   * properties:
-   */
-  constructor(keysNodesEntriesOrRaws = [], options) {
-    super([], options);
-    if (options) {
-      const { specifyComparable, isReverse } = options;
-      if (typeof specifyComparable === "function") this._specifyComparable = specifyComparable;
-      if (isReverse !== void 0) this._isReverse = isReverse;
-    }
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
-  }
-  _root = void 0;
-  get root() {
-    return this._root;
-  }
-  _isReverse = false;
-  get isReverse() {
-    return this._isReverse;
-  }
-  _comparator = (a, b) => {
-    if (isComparable(a) && isComparable(b)) {
-      if (a > b) return 1;
-      if (a < b) return -1;
-      return 0;
-    }
-    if (this._specifyComparable) {
-      if (this._specifyComparable(a) > this._specifyComparable(b)) return 1;
-      if (this._specifyComparable(a) < this._specifyComparable(b)) return -1;
-      return 0;
-    }
-    if (typeof a === "object" || typeof b === "object") {
-      throw TypeError(
-        `When comparing object types, a custom specifyComparable must be defined in the constructor's options parameter.`
-      );
-    }
-    return 0;
-  };
-  get comparator() {
-    return this._comparator;
-  }
-  _specifyComparable;
-  get specifyComparable() {
-    return this._specifyComparable;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function creates a new BSTNode with the given key and value and returns it.
-   * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
-   * being created.
-   * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
-   * value associated with the key in the node being created.
-   * @returns The method is returning a new instance of the BSTNode class, casted as the BSTNode<K, V> type.
-   */
-  createNode(key, value) {
-    return new BSTNode(key, this._isMapMode ? void 0 : value);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function creates a new binary search tree with the specified options.
-   * @param [options] - The `options` parameter is an optional object that allows you to customize the
-   * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which has the
-   * following properties:
-   * @returns a new instance of the BST class with the provided options.
-   */
-  createTree(options) {
-    return new _BST([], {
-      iterationType: this.iterationType,
-      isMapMode: this._isMapMode,
-      specifyComparable: this._specifyComparable,
-      toEntryFn: this._toEntryFn,
-      isReverse: this._isReverse,
-      ...options
-    });
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function ensures the existence of a node in a data structure and returns it, or undefined if
-   * it doesn't exist.
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can accept a value of type `R`, which represents the key, node,
-   * entry, or raw element that needs to be ensured in the tree.
-   * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
-   * parameter that specifies the type of iteration to be used when ensuring a node. It has a default
-   * value of `'ITERATIVE'`.
-   * @returns The method is returning either the node that was ensured or `undefined` if the node could
-   * not be ensured.
-   */
-  ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
-    return super.ensureNode(keyNodeOrEntry, iterationType) ?? void 0;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if the input is an instance of the BSTNode class.
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `.
-   * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
-   * an instance of the `BSTNode` class.
-   */
-  isNode(keyNodeOrEntry) {
-    return keyNodeOrEntry instanceof BSTNode;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function "override isValidKey" checks if a key is comparable based on a given comparator.
-   * @param {any} key - The `key` parameter is a value that will be checked to determine if it is of
-   * type `K`.
-   * @returns The `override isValidKey(key: any): key is K` function is returning a boolean value based on
-   * the result of the `isComparable` function with the condition `this._compare !==
-   * this._DEFAULT_COMPARATOR`.
-   */
-  isValidKey(key) {
-    return isComparable(key, this._specifyComparable !== void 0);
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can accept a value of type `R` or `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `.
-   * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
-   * key in the binary search tree. If provided, it will be stored in the node along with the key.
-   * @returns a boolean value.
-   */
-  add(keyNodeOrEntry, value) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
-    if (newNode === void 0) return false;
-    if (this._root === void 0) {
-      this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
-      this._size++;
-      return true;
-    }
-    let current = this._root;
-    while (current !== void 0) {
-      if (this._compare(current.key, newNode.key) === 0) {
-        this._replaceNode(current, newNode);
-        if (this._isMapMode) this._setValue(current.key, newValue);
-        return true;
-      } else if (this._compare(current.key, newNode.key) > 0) {
-        if (current.left === void 0) {
-          current.left = newNode;
-          if (this._isMapMode) this._setValue(newNode?.key, newValue);
-          this._size++;
-          return true;
-        }
-        if (current.left !== null) current = current.left;
-      } else {
-        if (current.right === void 0) {
-          current.right = newNode;
-          if (this._isMapMode) this._setValue(newNode?.key, newValue);
-          this._size++;
-          return true;
-        }
-        if (current.right !== null) current = current.right;
-      }
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(k log n)
-   * Space Complexity: O(k + log n)
-   *
-   * The `addMany` function in TypeScript adds multiple keys or nodes to a data structure and returns
-   * an array indicating whether each key or node was successfully inserted.
-   * @param keysNodesEntriesOrRaws - An iterable containing keys, nodes, entries, or raw
-   * elements to be added to the data structure.
-   * @param [values] - An optional iterable of values to be associated with the keys or nodes being
-   * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
-   * order. If not provided, undefined will be assigned as the value for each key or node.
-   * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-   * adding the elements. If set to true, the tree will be balanced using a binary search tree
-   * algorithm. If set to false, the elements will be added without balancing the tree. The default
-   * value is true.
-   * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
-   * specifies the type of iteration to use when adding multiple keys or nodes to the binary search
-   * tree. It can have two possible values:
-   * @returns The function `addMany` returns an array of booleans indicating whether each element was
-   * successfully inserted into the data structure.
-   */
-  addMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
-    const inserted = [];
-    let valuesIterator;
-    if (values) {
-      valuesIterator = values[Symbol.iterator]();
-    }
-    if (!isBalanceAdd) {
-      for (let kve of keysNodesEntriesOrRaws) {
-        const value = valuesIterator?.next().value;
-        if (this.isRaw(kve)) kve = this._toEntryFn(kve);
-        inserted.push(this.add(kve, value));
-      }
-      return inserted;
-    }
-    const realBTNExemplars = [];
-    let i = 0;
-    for (const kve of keysNodesEntriesOrRaws) {
-      realBTNExemplars.push({ key: kve, value: valuesIterator?.next().value, orgIndex: i });
-      i++;
-    }
-    let sorted = [];
-    sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
-      let keyA, keyB;
-      if (this.isRaw(a)) keyA = this._toEntryFn(a)[0];
-      else if (this.isEntry(a)) keyA = a[0];
-      else if (this.isRealNode(a)) keyA = a.key;
-      else {
-        keyA = a;
-      }
-      if (this.isRaw(b)) keyB = this._toEntryFn(b)[0];
-      else if (this.isEntry(b)) keyB = b[0];
-      else if (this.isRealNode(b)) keyB = b.key;
-      else {
-        keyB = b;
-      }
-      if (keyA !== void 0 && keyA !== null && keyB !== void 0 && keyB !== null) {
-        return this._compare(keyA, keyB);
-      }
-      return 0;
-    });
-    const _dfs = (arr) => {
-      if (arr.length === 0) return;
-      const mid = Math.floor((arr.length - 1) / 2);
-      const { key, value } = arr[mid];
-      const { orgIndex } = arr[mid];
-      if (this.isRaw(key)) {
-        const entry = this._toEntryFn(key);
-        inserted[orgIndex] = this.add(entry);
-      } else {
-        inserted[orgIndex] = this.add(key, value);
-      }
-      _dfs(arr.slice(0, mid));
-      _dfs(arr.slice(mid + 1));
-    };
-    const _iterate = () => {
-      const n = sorted.length;
-      const stack = [[0, n - 1]];
-      while (stack.length > 0) {
-        const popped = stack.pop();
-        if (popped) {
-          const [l, r] = popped;
-          if (l <= r) {
-            const m = l + Math.floor((r - l) / 2);
-            const { key, value } = sorted[m];
-            const { orgIndex } = sorted[m];
-            if (this.isRaw(key)) {
-              const entry = this._toEntryFn(key);
-              inserted[orgIndex] = this.add(entry);
-            } else {
-              inserted[orgIndex] = this.add(key, value);
-            }
-            stack.push([m + 1, r]);
-            stack.push([l, m - 1]);
-          }
-        }
-      }
-    };
-    if (iterationType === "RECURSIVE") {
-      _dfs(sorted);
-    } else {
-      _iterate();
-    }
-    return inserted;
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(k + log n)
-   *
-   * The function `search` in TypeScript overrides the search behavior in a binary tree structure based
-   * on specified criteria.
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The
-   * `keyNodeEntryOrPredicate` parameter in the `override search` method can accept one of the
-   * following types:
-   * @param [onlyOne=false] - The `onlyOne` parameter is a boolean flag that determines whether the
-   * search should stop after finding the first matching node. If `onlyOne` is set to `true`, the
-   * search will return as soon as a matching node is found. If `onlyOne` is set to `false`, the
-   * @param {C} callback - The `callback` parameter in the `override search` function is a function
-   * that will be called on each node that matches the search criteria. It is of type `C`, which
-   * extends `NodeCallback<BSTNode<K, V> | null>`. The callback function should accept a node of type `BSTNode<K, V>` as its
-   * argument and
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `override search`
-   * method represents the node from which the search operation will begin. It is the starting point
-   * for searching within the tree data structure. The method ensures that the `startNode` is a valid
-   * node before proceeding with the search operation. If the `
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `override search`
-   * function determines the type of iteration to be used during the search operation. It can have two
-   * possible values:
-   * @returns The `override search` method returns an array of values that match the search criteria
-   * specified by the input parameters. The method performs a search operation on a binary tree
-   * structure based on the provided key, predicate, and other options. The search results are
-   * collected in an array and returned as the output of the method.
-   */
-  search(keyNodeEntryOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    if (keyNodeEntryOrPredicate === void 0) return [];
-    if (keyNodeEntryOrPredicate === null) return [];
-    startNode = this.ensureNode(startNode);
-    if (!startNode) return [];
-    let predicate;
-    const isRange = this.isRange(keyNodeEntryOrPredicate);
-    if (isRange) {
-      predicate = (node) => {
-        if (!node) return false;
-        return keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
-      };
-    } else {
-      predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
-    }
-    const shouldVisitLeft = (cur) => {
-      if (!cur) return false;
-      if (!this.isRealNode(cur.left)) return false;
-      if (isRange) {
-        const range = keyNodeEntryOrPredicate;
-        const leftS = this.isReverse ? range.high : range.low;
-        const leftI = this.isReverse ? range.includeHigh : range.includeLow;
-        return leftI && this._compare(cur.key, leftS) >= 0 || !leftI && this._compare(cur.key, leftS) > 0;
-      }
-      if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
-        const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
-        return benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) > 0;
-      }
-      return true;
-    };
-    const shouldVisitRight = (cur) => {
-      if (!cur) return false;
-      if (!this.isRealNode(cur.right)) return false;
-      if (isRange) {
-        const range = keyNodeEntryOrPredicate;
-        const rightS = this.isReverse ? range.low : range.high;
-        const rightI = this.isReverse ? range.includeLow : range.includeLow;
-        return rightI && this._compare(cur.key, rightS) <= 0 || !rightI && this._compare(cur.key, rightS) < 0;
-      }
-      if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
-        const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
-        return benchmarkKey !== null && benchmarkKey !== void 0 && this._compare(cur.key, benchmarkKey) < 0;
-      }
-      return true;
-    };
-    return super._dfs(
-      callback,
-      "IN",
-      onlyOne,
-      startNode,
-      iterationType,
-      false,
-      shouldVisitLeft,
-      shouldVisitRight,
-      () => true,
-      (cur) => {
-        if (cur) return predicate(cur);
-        return false;
-      }
-    );
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(k + log n)
-   *
-   * The `rangeSearch` function searches for nodes within a specified range in a binary search tree.
-   * @param {Range<K> | [K, K]} range - The `range` parameter in the `rangeSearch` function can be
-   * either a `Range` object or an array of two elements representing the range boundaries.
-   * @param {C} callback - The `callback` parameter in the `rangeSearch` function is a callback
-   * function that is used to process each node that is found within the specified range during the
-   * search operation. It is of type `NodeCallback<BSTNode<K, V> | null>`, where `BSTNode<K, V>` is the type of nodes in the
-   * data structure.
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `rangeSearch`
-   * function represents the node from which the search for nodes within the specified range will
-   * begin. It is the starting point for the range search operation.
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `rangeSearch` function
-   * is used to specify the type of iteration to be performed during the search operation. It has a
-   * default value of `this.iterationType`, which suggests that it is likely a property of the class or
-   * object that the `rangeSearch`
-   * @returns The `rangeSearch` function is returning the result of calling the `search` method with
-   * the specified parameters.
-   */
-  rangeSearch(range, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    const searchRange = range instanceof Range ? range : new Range(range[0], range[1]);
-    return this.search(searchRange, false, callback, startNode, iterationType);
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * This function retrieves a node based on a given keyNodeEntryOrPredicate within a binary search tree structure.
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate`
-   * parameter can be of type `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `, `R`, or `NodePredicate<BSTNode<K, V>>`.
-   * @param {BSTNOptKeyOrNode<K, BSTNode<K, V>>} startNode - The `startNode` parameter in the `getNode` method
-   * is used to specify the starting point for searching nodes in the binary search tree. If no
-   * specific starting point is provided, the default value is set to `this._root`, which is the root
-   * node of the binary search tree.
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `getNode` method is a
-   * parameter that specifies the type of iteration to be used. It has a default value of
-   * `this.iterationType`, which means it will use the iteration type defined in the class instance if
-   * no value is provided when calling the method.
-   * @returns The `getNode` method is returning an optional binary search tree node (`OptNode<BSTNode<K, V>>`).
-   * It is using the `getNodes` method to find the node based on the provided keyNodeEntryOrPredicate, beginning at
-   * the specified root node (`startNode`) and using the specified iteration type. The method then
-   * returns the first node found or `undefined` if no node is found.
-   */
-  getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? void 0;
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The function `dfs` in TypeScript overrides the base class method with default parameters and
-   * returns the result of the super class `dfs` method.
-   * @param {C} callback - The `callback` parameter is a function that will be called for each node
-   * visited during the Depth-First Search traversal. It is a generic type `C` that extends the
-   * `NodeCallback` interface for `BSTNode<K, V>`. The default value for `callback` is `this._
-   * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `override dfs` method
-   * specifies the order in which the Depth-First Search (DFS) traversal should be performed on the
-   * Binary Search Tree (BST). The possible values for the `pattern` parameter are:
-   * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `override dfs` method is a
-   * boolean flag that indicates whether you want to stop the depth-first search traversal after
-   * finding the first matching node or continue searching for all matching nodes. If `onlyOne` is set
-   * to `true`, the traversal will stop after finding
-   * @param {K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} startNode -
-   * The `startNode` parameter in the `override dfs` method can be one of the following types:
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `override dfs` method
-   * specifies the type of iteration to be performed during the Depth-First Search (DFS) traversal of a
-   * Binary Search Tree (BST). It is used to determine the order in which nodes are visited during the
-   * traversal. The possible values for `
-   * @returns The `override` function is returning the result of calling the `dfs` method from the
-   * superclass, with the provided arguments `callback`, `pattern`, `onlyOne`, `startNode`, and
-   * `iterationType`. The return type is an array of the return type of the callback function `C`.
-   */
-  dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = "IN", onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
-    return super.dfs(callback, pattern, onlyOne, startNode, iterationType);
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The function overrides the breadth-first search method and returns an array of the return types of
-   * the callback function.
-   * @param {C} callback - The `callback` parameter is a function that will be called for each node
-   * visited during the breadth-first search. It should take a single argument, which is the current
-   * node being visited, and it can return a value of any type.
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
-   * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
-   * object. If no value is provided, the default value is the root of the tree.
-   * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
-   * of iteration to be performed during the breadth-first search (BFS) traversal. It can have one of
-   * the following values:
-   * @returns an array of the return type of the callback function.
-   */
-  bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    return super.bfs(callback, startNode, iterationType, false);
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The function overrides the listLevels method from the superclass and returns an array of arrays
-   * containing the results of the callback function applied to each level of the tree.
-   * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-   * `NodeCallback<BSTNode<K, V> | null>`. It represents a callback function that will be called for each node in the
-   * tree during the iteration process.
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
-   * point for listing the levels of the binary tree. It can be either a root node of the tree, a
-   * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
-   * value is provided, the root of
-   * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
-   * of iteration to be performed on the tree. It can have one of the following values:
-   * @returns The method is returning a two-dimensional array of the return type of the callback
-   * function.
-   */
-  listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-    return super.listLevels(callback, startNode, iterationType, false);
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The `lesserOrGreaterTraverse` function traverses a binary tree and applies a callback function to
-   * each node that meets a certain condition based on a target node and a comparison value.
-   * @param {C} callback - The `callback` parameter is a function that will be called for each node
-   * that meets the condition specified by the `lesserOrGreater` parameter. It takes a single argument,
-   * which is the current node being traversed, and returns a value of any type.
-   * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
-   * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
-   * 0, or 1, where:
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } targetNode - The `targetNode` parameter is the node in
-   * the binary tree that you want to start traversing from. It can be specified either by providing
-   * the key of the node, the node itself, or an entry containing the key and value of the node. If no
-   * `targetNode` is provided,
-   * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
-   * traversal to be performed on the binary tree. It can have two possible values:
-   * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
-   * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
-   */
-  lesserOrGreaterTraverse(callback = this._DEFAULT_NODE_CALLBACK, lesserOrGreater = -1, targetNode = this._root, iterationType = this.iterationType) {
-    const targetNodeEnsured = this.ensureNode(targetNode);
-    const ans = [];
-    if (!this._root) return ans;
-    if (!targetNodeEnsured) return ans;
-    const targetKey = targetNodeEnsured.key;
-    if (iterationType === "RECURSIVE") {
-      const dfs = (cur) => {
-        const compared = this._compare(cur.key, targetKey);
-        if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
-        if (this.isRealNode(cur.left)) dfs(cur.left);
-        if (this.isRealNode(cur.right)) dfs(cur.right);
-      };
-      dfs(this._root);
-      return ans;
-    } else {
-      const queue = new Queue([this._root]);
-      while (queue.length > 0) {
-        const cur = queue.shift();
-        if (this.isRealNode(cur)) {
-          const compared = this._compare(cur.key, targetKey);
-          if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
-          if (this.isRealNode(cur.left)) queue.push(cur.left);
-          if (this.isRealNode(cur.right)) queue.push(cur.right);
-        }
-      }
-      return ans;
-    }
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The `perfectlyBalance` function takes an optional `iterationType` parameter and returns `true` if
-   * the binary search tree is perfectly balanced, otherwise it returns `false`.
-   * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
-   * specifies the type of iteration to use when building a balanced binary search tree. It has a
-   * default value of `this.iterationType`, which means it will use the iteration type specified in the
-   * current instance of the class.
-   * @returns The function `perfectlyBalance` returns a boolean value.
-   */
-  perfectlyBalance(iterationType = this.iterationType) {
-    const sorted = this.dfs((node) => node, "IN"), n = sorted.length;
-    this._clearNodes();
-    if (sorted.length < 1) return false;
-    if (iterationType === "RECURSIVE") {
-      const buildBalanceBST = (l, r) => {
-        if (l > r) return;
-        const m = l + Math.floor((r - l) / 2);
-        const midNode = sorted[m];
-        if (this._isMapMode && midNode !== null) this.add(midNode.key);
-        else if (midNode !== null) this.add([midNode.key, midNode.value]);
-        buildBalanceBST(l, m - 1);
-        buildBalanceBST(m + 1, r);
-      };
-      buildBalanceBST(0, n - 1);
-      return true;
-    } else {
-      const stack = [[0, n - 1]];
-      while (stack.length > 0) {
-        const popped = stack.pop();
-        if (popped) {
-          const [l, r] = popped;
-          if (l <= r) {
-            const m = l + Math.floor((r - l) / 2);
-            const midNode = sorted[m];
-            if (this._isMapMode && midNode !== null) this.add(midNode.key);
-            else if (midNode !== null) this.add([midNode.key, midNode.value]);
-            stack.push([m + 1, r]);
-            stack.push([l, m - 1]);
-          }
-        }
-      }
-      return true;
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   *
-   * The function `isAVLBalanced` checks if a binary tree is AVL balanced using either a recursive or
-   * iterative approach.
-   * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
-   * specifies the type of iteration to use when checking if the AVL tree is balanced. It has a default
-   * value of `this.iterationType`, which means it will use the iteration type specified in the current
-   * instance of the AVL tree.
-   * @returns a boolean value.
-   */
-  isAVLBalanced(iterationType = this.iterationType) {
-    if (!this._root) return true;
-    let balanced = true;
-    if (iterationType === "RECURSIVE") {
-      const _height = (cur) => {
-        if (!cur) return 0;
-        const leftHeight = _height(cur.left), rightHeight = _height(cur.right);
-        if (Math.abs(leftHeight - rightHeight) > 1) balanced = false;
-        return Math.max(leftHeight, rightHeight) + 1;
-      };
-      _height(this._root);
-    } else {
-      const stack = [];
-      let node = this._root, last = void 0;
-      const depths = /* @__PURE__ */ new Map();
-      while (stack.length > 0 || node) {
-        if (node) {
-          stack.push(node);
-          if (node.left !== null) node = node.left;
-        } else {
-          node = stack[stack.length - 1];
-          if (!node.right || last === node.right) {
-            node = stack.pop();
-            if (node) {
-              const left = node.left ? depths.get(node.left) : -1;
-              const right = node.right ? depths.get(node.right) : -1;
-              if (Math.abs(left - right) > 1) return false;
-              depths.set(node, 1 + Math.max(left, right));
-              last = node;
-              node = void 0;
-            }
-          } else node = node.right;
-        }
-      }
-    }
-    return balanced;
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The `map` function in TypeScript overrides the default map behavior for a binary search tree by
-   * applying a callback function to each entry and creating a new tree with the results.
-   * @param callback - A function that will be called for each entry in the BST. It takes four
-   * arguments: the key, the value (which can be undefined), the index of the entry, and a reference to
-   * the BST itself.
-   * @param [options] - The `options` parameter in the `override map` method is of type `BSTOptions<MK,
-   * MV, MR>`. It is an optional parameter that allows you to specify additional options for the Binary
-   * Search Tree (BST) being created in the `map` method. These options could include configuration
-   * @param {any} [thisArg] - The `thisArg` parameter in the `override map` method is used to specify
-   * the value of `this` that should be used when executing the `callback` function. It allows you to
-   * set the context or scope in which the callback function will be called. This can be useful when
-   * you want
-   * @returns The `map` method is returning a new Binary Search Tree (`BST`) instance with the entries
-   * transformed by the provided callback function.
-   */
-  map(callback, options, thisArg) {
-    const newTree = new _BST([], options);
-    let index = 0;
-    for (const [key, value] of this) {
-      newTree.add(callback.call(thisArg, key, value, index++, this));
-    }
-    return newTree;
-  }
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   *
-   * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
-   * structure.
-   * @returns The `cloned` object is being returned.
-   */
-  clone() {
-    const cloned = this.createTree();
-    this._clone(cloned);
-    return cloned;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - A variable that can be of
-   * type R or K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  . It represents either a key, a node, an entry, or a raw
-   * element.
-   * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
-   * value associated with a key in a key-value pair.
-   * @returns either a BSTNode<K, V> object or undefined.
-   */
-  _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
-    const [node, entryValue] = super._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
-    if (node === null) return [void 0, void 0];
-    return [node, value ?? entryValue];
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function sets the root of a tree-like structure and updates the parent property of the new
-   * root.
-   * @param {OptNode<BSTNode<K, V>>} v - v is a parameter of type BSTNode<K, V> or undefined.
-   */
-  _setRoot(v) {
-    if (v) {
-      v.parent = void 0;
-    }
-    this._root = v;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The _compare function compares two values using a specified comparator function and optionally
-   * reverses the result.
-   * @param {K} a - The parameter `a` is of type `K`, which is used as an input for comparison in the
-   * `_compare` method.
-   * @param {K} b - The parameter `b` in the `_compare` function is of type `K`.
-   * @returns The `_compare` method is returning the result of the ternary expression. If `_isReverse`
-   * is true, it returns the negation of the result of calling the `_comparator` function with
-   * arguments `a` and `b`. If `_isReverse` is false, it returns the result of calling the
-   * `_comparator` function with arguments `a` and `b`.
-   */
-  _compare(a, b) {
-    return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
-  }
-};
-
-// src/data-structures/binary-tree/red-black-tree.ts
-var RedBlackTreeNode = class extends BSTNode {
-  parent = void 0;
-  /**
-   * The constructor initializes a node with a key, value, and color for a Red-Black Tree.
-   * @param {K} key - The `key` parameter is a key of type `K` that is used to identify the node in a
-   * Red-Black Tree data structure.
-   * @param {V} [value] - The `value` parameter in the constructor is an optional parameter of type
-   * `V`. It represents the value associated with the key in the data structure being constructed.
-   * @param {RBTNColor} [color=BLACK] - The `color` parameter in the constructor is used to specify the
-   * color of the node in a Red-Black Tree. It has a default value of 'BLACK' if not provided
-   * explicitly.
-   */
-  constructor(key, value, color = "BLACK") {
-    super(key, value);
-    this._color = color;
-  }
-  _left = void 0;
-  get left() {
-    return this._left;
-  }
-  set left(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._left = v;
-  }
-  _right = void 0;
-  get right() {
-    return this._right;
-  }
-  set right(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._right = v;
-  }
-};
-var RedBlackTree = class _RedBlackTree extends BST {
-  /**
-   * This TypeScript constructor initializes a Red-Black Tree with optional keys, nodes, entries, or
-   * raw data.
-   * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain either `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined` objects or `R` objects. It
-   * is used to initialize the Red-Black Tree with keys, nodes, entries, or
-   * @param [options] - The `options` parameter in the constructor is of type `RedBlackTreeOptions<K,
-   * V, R>`. It is an optional parameter that allows you to specify additional options for the
-   * RedBlackTree class. These options could include configuration settings, behavior customization, or
-   * any other parameters that are specific to
-   */
-  constructor(keysNodesEntriesOrRaws = [], options) {
-    super([], options);
-    this._root = this.NIL;
-    if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
-    }
-  }
-  _root;
-  get root() {
-    return this._root;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function creates a new Red-Black Tree node with the specified key, value, and color.
-   * @param {K} key - The key parameter represents the key value of the node being created. It is of
-   * type K, which is a generic type that can be replaced with any specific type when using the
-   * function.
-   * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-   * associated with the key in the node. It is not required and can be omitted if you only need to
-   * create a node with a key.
-   * @param {RBTNColor} [color=BLACK] - The "color" parameter is used to specify the color of the node
-   * in a Red-Black Tree. It can have two possible values: "RED" or "BLACK". By default, the color is
-   * set to "BLACK" if not specified.
-   * @returns A new instance of a RedBlackTreeNode with the specified key, value, and color is being
-   * returned.
-   */
-  createNode(key, value, color = "BLACK") {
-    return new RedBlackTreeNode(key, this._isMapMode ? void 0 : value, color);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function creates a new Red-Black Tree with the specified options.
-   * @param [options] - The `options` parameter is an optional object that contains additional
-   * configuration options for creating the Red-Black Tree. It has the following properties:
-   * @returns a new instance of a RedBlackTree object.
-   */
-  createTree(options) {
-    return new _RedBlackTree([], {
-      iterationType: this.iterationType,
-      isMapMode: this._isMapMode,
-      specifyComparable: this._specifyComparable,
-      toEntryFn: this._toEntryFn,
-      ...options
-    });
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if the input is an instance of the RedBlackTreeNode class.
-   * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
-   * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
-   * an instance of the `RedBlackTreeNode` class.
-   */
-  isNode(keyNodeOrEntry) {
-    return keyNodeOrEntry instanceof RedBlackTreeNode;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The "clear" function sets the root node of a data structure to a sentinel value and resets the
-   * size counter to zero.
-   */
-  clear() {
-    super.clear();
-    this._root = this.NIL;
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function adds a new node to a binary search tree and returns true if the node was successfully
-   * added.
-   * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can accept a value of type `R` or `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
-   * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
-   * the key in the data structure. It represents the value that you want to add or update in the data
-   * structure.
-   * @returns The method is returning a boolean value. If a new node is successfully added to the tree,
-   * the method returns true. If the node already exists and its value is updated, the method also
-   * returns true. If the node cannot be added or updated, the method returns false.
-   */
-  add(keyNodeOrEntry, value) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
-    if (!this.isRealNode(newNode)) return false;
-    const insertStatus = this._insert(newNode);
-    if (insertStatus === "CREATED") {
-      if (this.isRealNode(this._root)) {
-        this._root.color = "BLACK";
-      } else {
-        return false;
-      }
-      if (this._isMapMode) this._setValue(newNode.key, newValue);
-      this._size++;
-      return true;
-    }
-    if (insertStatus === "UPDATED") {
-      if (this._isMapMode) this._setValue(newNode.key, newValue);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function overrides the delete method in a binary tree data structure to remove a node based on
-   * a given predicate and maintain the binary search tree properties.
-   * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `override delete` method is used to specify the condition or key based on which a
-   * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
-   * function that determines which node(s) should be deleted.
-   * @returns The `override delete` method is returning an array of `BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>`
-   * objects. Each object in the array contains information about the deleted node and whether
-   * balancing is needed.
-   */
-  delete(keyNodeOrEntry) {
-    if (keyNodeOrEntry === null) return [];
-    const results = [];
-    let nodeToDelete;
-    if (this._isPredicate(keyNodeOrEntry)) nodeToDelete = this.getNode(keyNodeOrEntry);
-    else nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
-    if (!nodeToDelete) {
-      return results;
-    }
-    let originalColor = nodeToDelete.color;
-    let replacementNode;
-    if (!this.isRealNode(nodeToDelete.left)) {
-      if (nodeToDelete.right !== null) {
-        replacementNode = nodeToDelete.right;
-        this._transplant(nodeToDelete, nodeToDelete.right);
-      }
-    } else if (!this.isRealNode(nodeToDelete.right)) {
-      replacementNode = nodeToDelete.left;
-      this._transplant(nodeToDelete, nodeToDelete.left);
-    } else {
-      const successor = this.getLeftMost((node) => node, nodeToDelete.right);
-      if (successor) {
-        originalColor = successor.color;
-        if (successor.right !== null) replacementNode = successor.right;
-        if (successor.parent === nodeToDelete) {
-          if (this.isRealNode(replacementNode)) {
-            replacementNode.parent = successor;
-          }
-        } else {
-          if (successor.right !== null) {
-            this._transplant(successor, successor.right);
-            successor.right = nodeToDelete.right;
-          }
-          if (this.isRealNode(successor.right)) {
-            successor.right.parent = successor;
-          }
-        }
-        this._transplant(nodeToDelete, successor);
-        successor.left = nodeToDelete.left;
-        if (this.isRealNode(successor.left)) {
-          successor.left.parent = successor;
-        }
-        successor.color = nodeToDelete.color;
-      }
-    }
-    if (this._isMapMode) this._store.delete(nodeToDelete.key);
-    this._size--;
-    if (originalColor === "BLACK") {
-      this._deleteFixup(replacementNode);
-    }
-    results.push({ deleted: nodeToDelete, needBalanced: void 0 });
-    return results;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
-   * applying a callback to each entry in the original tree.
-   * @param callback - A function that will be called for each entry in the tree, with parameters
-   * representing the key, value, index, and the tree itself. It should return an entry for the new
-   * tree.
-   * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
-   * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
-   * Tree that will be created during the mapping process. These options could include things like
-   * custom comparators
-   * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-   * the value of `this` when executing the `callback` function. It allows you to set the context
-   * (value of `this`) for the callback function. This can be useful when you want to access properties
-   * or
-   * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
-   * provided callback function.
-   */
-  map(callback, options, thisArg) {
-    const newTree = new _RedBlackTree([], options);
-    let index = 0;
-    for (const [key, value] of this) {
-      newTree.add(callback.call(thisArg, key, value, index++, this));
-    }
-    return newTree;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
-   * structure.
-   * @returns The `cloned` object is being returned.
-   */
-  clone() {
-    const cloned = this.createTree();
-    this._clone(cloned);
-    return cloned;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function sets the root of a tree-like structure and updates the parent property of the new
-   * root.
-   * @param {RedBlackTreeNode<K, V> | undefined} v - v is a parameter of type RedBlackTreeNode<K, V> or undefined.
-   */
-  _setRoot(v) {
-    if (v) {
-      v.parent = void 0;
-    }
-    this._root = v;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function replaces an old node with a new node while preserving the color of the old node.
-   * @param {RedBlackTreeNode<K, V>} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
-   * the data structure.
-   * @param {RedBlackTreeNode<K, V>} newNode - The `newNode` parameter is of type `RedBlackTreeNode<K, V>`, which represents a node in a
-   * data structure.
-   * @returns The method is returning the result of calling the `_replaceNode` method from the
-   * superclass, with the `oldNode` and `newNode` parameters.
-   */
-  _replaceNode(oldNode, newNode) {
-    newNode.color = oldNode.color;
-    return super._replaceNode(oldNode, newNode);
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The `_insert` function inserts a node into a binary search tree and performs necessary fix-ups to
-   * maintain the red-black tree properties.
-   * @param {RedBlackTreeNode<K, V>} node - The `node` parameter represents the node that needs to be inserted into the
-   * binary search tree.
-   * @returns a string value indicating the result of the insertion operation. It can return either
-   * 'UPDATED' if the node with the same key already exists and was updated, or 'CREATED' if a new node
-   * was created and inserted into the tree.
-   */
-  _insert(node) {
-    let current = this.root;
-    let parent = void 0;
-    while (this.isRealNode(current)) {
-      parent = current;
-      const compared = this._compare(node.key, current.key);
-      if (compared < 0) {
-        current = current.left ?? this.NIL;
-      } else if (compared > 0) {
-        current = current.right ?? this.NIL;
-      } else {
-        this._replaceNode(current, node);
-        return "UPDATED";
-      }
-    }
-    node.parent = parent;
-    if (!parent) {
-      this._setRoot(node);
-    } else if (this._compare(node.key, parent.key) < 0) {
-      parent.left = node;
-    } else {
-      parent.right = node;
-    }
-    node.left = this.NIL;
-    node.right = this.NIL;
-    node.color = "RED";
-    this._insertFixup(node);
-    return "CREATED";
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `_transplant` is used to replace a node `u` with another node `v` in a binary tree.
-   * @param {RedBlackTreeNode<K, V>} u - The parameter "u" represents a node in a binary tree.
-   * @param {RedBlackTreeNode<K, V> | undefined} v - The parameter `v` is of type `RedBlackTreeNode<K, V> | undefined`, which means it can
-   * either be a `RedBlackTreeNode<K, V>` object or `undefined`.
-   */
-  _transplant(u, v) {
-    if (!u.parent) {
-      this._setRoot(v);
-    } else if (u === u.parent.left) {
-      u.parent.left = v;
-    } else {
-      u.parent.right = v;
-    }
-    if (v) {
-      v.parent = u.parent;
-    }
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   *
-   * The `_insertFixup` function is used to fix the Red-Black Tree after inserting a new node.
-   * @param {RedBlackTreeNode<K, V> | undefined} z - The parameter `z` represents a node in the Red-Black Tree data
-   * structure. It can either be a valid node or `undefined`.
-   */
-  _insertFixup(z) {
-    while (z?.parent?.color === "RED") {
-      if (z.parent === z.parent.parent?.left) {
-        const y = z.parent.parent.right;
-        if (y?.color === "RED") {
-          z.parent.color = "BLACK";
-          y.color = "BLACK";
-          z.parent.parent.color = "RED";
-          z = z.parent.parent;
-        } else {
-          if (z === z.parent.right) {
-            z = z.parent;
-            this._leftRotate(z);
-          }
-          if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-            z.parent.color = "BLACK";
-            z.parent.parent.color = "RED";
-            this._rightRotate(z.parent.parent);
-          }
-        }
-      } else {
-        const y = z?.parent?.parent?.left ?? void 0;
-        if (y?.color === "RED") {
-          z.parent.color = "BLACK";
-          y.color = "BLACK";
-          z.parent.parent.color = "RED";
-          z = z.parent.parent;
-        } else {
-          if (z === z.parent.left) {
-            z = z.parent;
-            this._rightRotate(z);
-          }
-          if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-            z.parent.color = "BLACK";
-            z.parent.parent.color = "RED";
-            this._leftRotate(z.parent.parent);
-          }
-        }
-      }
-    }
-    if (this.isRealNode(this._root)) this._root.color = "BLACK";
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   *
-   * The `_deleteFixup` function is used to fix the red-black tree after a node deletion by adjusting
-   * the colors and performing rotations.
-   * @param {RedBlackTreeNode<K, V> | undefined} node - The `node` parameter represents a node in a binary tree. It can
-   * be either a valid node object or `undefined`.
-   * @returns The function does not return any value. It has a return type of `void`, which means it
-   * does not return anything.
-   */
-  _deleteFixup(node) {
-    if (!node || node === this.root || node.color === "BLACK") {
-      if (node) {
-        node.color = "BLACK";
-      }
-      return;
-    }
-    while (node && node !== this.root && node.color === "BLACK") {
-      const parent = node.parent;
-      if (!parent) {
-        break;
-      }
-      if (node === parent.left) {
-        let sibling = parent.right;
-        if (sibling?.color === "RED") {
-          sibling.color = "BLACK";
-          parent.color = "RED";
-          this._leftRotate(parent);
-          sibling = parent.right;
-        }
-        if ((sibling?.left?.color ?? "BLACK") === "BLACK") {
-          if (sibling) sibling.color = "RED";
-          node = parent;
-        } else {
-          if (sibling?.left) sibling.left.color = "BLACK";
-          if (sibling) sibling.color = parent.color;
-          parent.color = "BLACK";
-          this._rightRotate(parent);
-          node = this.root;
-        }
-      } else {
-        let sibling = parent.left;
-        if (sibling?.color === "RED") {
-          sibling.color = "BLACK";
-          if (parent) parent.color = "RED";
-          this._rightRotate(parent);
-          if (parent) sibling = parent.left;
-        }
-        if ((sibling?.right?.color ?? "BLACK") === "BLACK") {
-          if (sibling) sibling.color = "RED";
-          node = parent;
-        } else {
-          if (sibling?.right) sibling.right.color = "BLACK";
-          if (sibling) sibling.color = parent.color;
-          if (parent) parent.color = "BLACK";
-          this._leftRotate(parent);
-          node = this.root;
-        }
-      }
-    }
-    if (node) {
-      node.color = "BLACK";
-    }
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `_leftRotate` function performs a left rotation on a given node in a binary tree.
-   * @param {RedBlackTreeNode<K, V> | undefined} x - The parameter `x` is of type `RedBlackTreeNode<K, V> | undefined`. It represents a
-   * node in a binary tree or `undefined` if there is no node.
-   * @returns void, which means it does not return any value.
-   */
-  _leftRotate(x) {
-    if (!x || !x.right) {
-      return;
-    }
-    const y = x.right;
-    x.right = y.left;
-    if (this.isRealNode(y.left)) {
-      y.left.parent = x;
-    }
-    y.parent = x.parent;
-    if (!x.parent) {
-      this._setRoot(y);
-    } else if (x === x.parent.left) {
-      x.parent.left = y;
-    } else {
-      x.parent.right = y;
-    }
-    y.left = x;
-    x.parent = y;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `_rightRotate` function performs a right rotation on a given node in a binary tree.
-   * @param {RedBlackTreeNode<K, V> | undefined} y - The parameter `y` is of type `RedBlackTreeNode<K, V> | undefined`. It represents a
-   * node in a binary tree or `undefined` if there is no node.
-   * @returns void, which means it does not return any value.
-   */
-  _rightRotate(y) {
-    if (!y || !y.left) {
-      return;
-    }
-    const x = y.left;
-    y.left = x.right;
-    if (this.isRealNode(x.right)) {
-      x.right.parent = y;
-    }
-    x.parent = y.parent;
-    if (!y.parent) {
-      this._setRoot(x);
-    } else if (y === y.parent.left) {
-      y.parent.left = x;
-    } else {
-      y.parent.right = x;
-    }
-    x.right = y;
-    y.parent = x;
-  }
-};
-
-// src/data-structures/binary-tree/tree-multi-map.ts
-var TreeMultiMapNode = class extends RedBlackTreeNode {
-  parent = void 0;
-  /**
-   * This TypeScript constructor initializes an object with a key of type K and an array of values of
-   * type V.
-   * @param {K} key - The `key` parameter is typically used to store a unique identifier or key for the
-   * data being stored in the data structure. It helps in quickly accessing or retrieving the
-   * associated value in the data structure.
-   * @param {V[]} value - The `value` parameter in the constructor represents an array of values of
-   * type `V`.
-   */
-  constructor(key, value) {
-    super(key, value);
-  }
-  _left = void 0;
-  get left() {
-    return this._left;
-  }
-  set left(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._left = v;
-  }
-  _right = void 0;
-  get right() {
-    return this._right;
-  }
-  set right(v) {
-    if (v) {
-      v.parent = this;
-    }
-    this._right = v;
-  }
-};
-var TreeMultiMap = class _TreeMultiMap extends RedBlackTree {
-  /**
-   * The constructor initializes an TreeMultiMap with the provided keys, nodes, entries, or raw data
-   * and options.
-   * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain either key-value pairs represented as `BTNRep<K, V[],
-   * TreeMultiMapNode<K, V>>` or raw data represented as `R`. This parameter is used to initialize
-   * the RedBlackTreeMulti
-   * @param [options] - The `options` parameter in the constructor is of type
-   * `TreeMultiMapOptions<K, V[], R>`. It is an optional parameter that allows you to specify
-   * additional options for configuring the TreeMultiMap instance.
-   */
-  constructor(keysNodesEntriesOrRaws = [], options) {
-    super([], { ...options });
-    if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
-    }
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `createTree` function in TypeScript overrides the default implementation to create a new
-   * TreeMultiMap with specified options.
-   * @param [options] - The `options` parameter in the `createTree` method is of type
-   * `TreeMultiMapOptions<K, V[], R>`. This parameter allows you to pass additional configuration
-   * options when creating a new `TreeMultiMap` instance. It includes properties such as
-   * `iterationType`, `specifyComparable
-   * @returns A new instance of `TreeMultiMap` is being returned, with an empty array as the initial
-   * data and the provided options merged with the existing properties of the current object.
-   */
-  createTree(options) {
-    return new _TreeMultiMap([], {
-      iterationType: this.iterationType,
-      specifyComparable: this._specifyComparable,
-      toEntryFn: this._toEntryFn,
-      isReverse: this._isReverse,
-      isMapMode: this._isMapMode,
-      ...options
-    });
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `createNode` overrides the creation of a new TreeMultiMapNode with a specified key
-   * and value array.
-   * @param {K} key - The `key` parameter represents the key of the node being created in the
-   * `TreeMultiMap`.
-   * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
-   * values associated with a specific key in the TreeMultiMap data structure.
-   * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned with the specified key and
-   * value. If `_isMapMode` is true, an empty array is passed as the value, otherwise the provided
-   * value is used.
-   */
-  createNode(key, value = []) {
-    return new TreeMultiMapNode(key, this._isMapMode ? [] : value);
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function overrides the add method to handle different types of input for a TreeMultiMap data
-   * structure.
-   * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
-   * be added to the TreeMultiMap. It can be of type `K`, which is the key type of the TreeMultiMap, or
-   * it can be a TreeMultiMapNode containing the key and its
-   * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
-   * that you want to add to the TreeMultiMap. It can contain one or more values of type `V`.
-   * @returns The `add` method is returning a boolean value, which indicates whether the operation was
-   * successful or not.
-   */
-  add(keyNodeOrEntry, value) {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
-    const _commonAdd = (key, values) => {
-      if (key === void 0 || key === null) return false;
-      const _addToValues = () => {
-        const existingValues = this.get(key);
-        if (existingValues !== void 0 && values !== void 0) {
-          for (const value2 of values) existingValues.push(value2);
-          return true;
-        }
-        return false;
-      };
-      const _addByNode = () => {
-        const existingNode = this.getNode(key);
-        if (this.isRealNode(existingNode)) {
-          const existingValues = this.get(existingNode);
-          if (existingValues === void 0) {
-            super.add(key, values);
-            return true;
-          }
-          if (values !== void 0) {
-            for (const value2 of values) existingValues.push(value2);
-            return true;
-          } else {
-            return false;
-          }
-        } else {
-          return super.add(key, values);
-        }
-      };
-      if (this._isMapMode) {
-        return _addByNode() || _addToValues();
-      }
-      return _addToValues() || _addByNode();
-    };
-    if (this.isEntry(keyNodeOrEntry)) {
-      const [key, values] = keyNodeOrEntry;
-      return _commonAdd(key, value !== void 0 ? [value] : values);
-    }
-    return _commonAdd(keyNodeOrEntry, value !== void 0 ? [value] : void 0);
-  }
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   *
-   * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
-   * and deletes the entire node if no values are left for that key.
-   * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
-   * array of values, or just a key itself.
-   * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
-   * value that you want to remove from the multi-map data structure associated with a particular key.
-   * The function checks if the value exists in the array of values associated with the key, and if
-   * found, removes it from the array.
-   * @returns The `deleteValue` function returns a boolean value - `true` if the specified `value` was
-   * successfully deleted from the values associated with the `keyNodeOrEntry`, and `false` otherwise.
-   */
-  deleteValue(keyNodeOrEntry, value) {
-    const values = this.get(keyNodeOrEntry);
-    if (Array.isArray(values)) {
-      const index = values.indexOf(value);
-      if (index === -1) return false;
-      values.splice(index, 1);
-      if (values.length === 0) this.delete(keyNodeOrEntry);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
-   * structure.
-   * @returns The `cloned` object is being returned.
-   */
-  clone() {
-    const cloned = this.createTree();
-    this._clone(cloned);
-    return cloned;
-  }
-};
-export {
-  TreeMultiMap,
-  TreeMultiMapNode
-};
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-/**
- * @license MIT
- * @copyright Pablo Zeng <zrwusa@gmail.com>
- * @class
- */