data-structure-typed 1.54.3 → 2.0.1

package/dist/individuals/graph/directed-graph.mjs

@@ -0,0 +1,2910 @@
+// src/utils/utils.ts
+var uuidV4 = function() {
+  return "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/[x]/g, function(c) {
+    const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+var arrayRemove = function(array, predicate) {
+  let i = -1, len = array ? array.length : 0;
+  const result = [];
+  while (++i < len) {
+    const value = array[i];
+    if (predicate(value, i, array)) {
+      result.push(value);
+      Array.prototype.splice.call(array, i--, 1);
+      len--;
+    }
+  }
+  return result;
+};
+var THUNK_SYMBOL = Symbol("thunk");
+
+// 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/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/heap/heap.ts
+var Heap = class _Heap extends IterableElementBase {
+  /**
+   * The constructor initializes a heap data structure with optional elements and options.
+   * @param elements - The `elements` parameter is an iterable object that contains the initial
+   * elements to be added to the heap.
+   * It is an optional parameter, and if not provided, the heap will
+   * be initialized as empty.
+   * @param [options] - The `options` parameter is an optional object that can contain additional
+   * configuration options for the heap.
+   * In this case, it is used to specify a custom comparator
+   * function for comparing elements in the heap.
+   * The comparator function is used to determine the
+   * order of elements in the heap.
+   */
+  constructor(elements = [], options) {
+    super(options);
+    if (options) {
+      const { comparator } = options;
+      if (comparator) this._comparator = comparator;
+    }
+    this.addMany(elements);
+  }
+  _elements = [];
+  /**
+   * The function returns an array of elements.
+   * @returns The element array is being returned.
+   */
+  get elements() {
+    return this._elements;
+  }
+  /**
+   * Get the size (number of elements) of the heap.
+   */
+  get size() {
+    return this.elements.length;
+  }
+  /**
+   * Get the last element in the heap, which is not necessarily a leaf node.
+   * @returns The last element or undefined if the heap is empty.
+   */
+  get leaf() {
+    return this.elements[this.size - 1] ?? void 0;
+  }
+  /**
+   * Static method that creates a binary heap from an array of elements and a comparison function.
+   * @returns A new Heap instance.
+   * @param elements
+   * @param options
+   */
+  static heapify(elements, options) {
+    return new _Heap(elements, options);
+  }
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * The add function pushes an element into an array and then triggers a bubble-up operation.
+   * @param {E} element - The `element` parameter represents the element that you want to add to the
+   * data structure.
+   * @returns The `add` method is returning a boolean value, which is the result of calling the
+   * `_bubbleUp` method with the index `this.elements.length - 1` as an argument.
+   */
+  add(element) {
+    this._elements.push(element);
+    return this._bubbleUp(this.elements.length - 1);
+  }
+  /**
+   * Time Complexity: O(k log n)
+   * Space Complexity: O(1)
+   *
+   * The `addMany` function iterates over elements and adds them to a collection, returning an array of
+   * boolean values indicating success or failure.
+   * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `addMany` method is
+   * an iterable containing elements of type `E` or `R`. The method iterates over each element in the
+   * iterable and adds them to the data structure. If a transformation function `_toElementFn` is
+   * provided, it transforms the element
+   * @returns The `addMany` method returns an array of boolean values indicating whether each element
+   * in the input iterable was successfully added to the data structure.
+   */
+  addMany(elements) {
+    const ans = [];
+    for (const el of elements) {
+      if (this._toElementFn) {
+        ans.push(this.add(this._toElementFn(el)));
+        continue;
+      }
+      ans.push(this.add(el));
+    }
+    return ans;
+  }
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * Remove and return the top element (the smallest or largest element) from the heap.
+   * @returns The top element or undefined if the heap is empty.
+   */
+  poll() {
+    if (this.elements.length === 0) return;
+    const value = this.elements[0];
+    const last = this.elements.pop();
+    if (this.elements.length) {
+      this.elements[0] = last;
+      this._sinkDown(0, this.elements.length >> 1);
+    }
+    return value;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * Peek at the top element of the heap without removing it.
+   * @returns The top element or undefined if the heap is empty.
+   */
+  peek() {
+    return this.elements[0];
+  }
+  /**
+   * Check if the heap is empty.
+   * @returns True if the heap is empty, otherwise false.
+   */
+  isEmpty() {
+    return this.size === 0;
+  }
+  /**
+   * Reset the elements of the heap. Make the elements empty.
+   */
+  clear() {
+    this._elements = [];
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * Clear and add elements of the heap
+   * @param elements
+   */
+  refill(elements) {
+    this._elements = elements;
+    return this.fix();
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * Use a comparison function to check whether a binary heap contains a specific element.
+   * @param element - the element to check.
+   * @returns Returns true if the specified element is contained; otherwise, returns false.
+   */
+  has(element) {
+    return this.elements.includes(element);
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `delete` function removes an element from an array-like data structure, maintaining the order
+   * and structure of the remaining elements.
+   * @param {E} element - The `element` parameter represents the element that you want to delete from
+   * the array `this.elements`.
+   * @returns The `delete` function is returning a boolean value. It returns `true` if the element was
+   * successfully deleted from the array, and `false` if the element was not found in the array.
+   */
+  delete(element) {
+    const index = this.elements.indexOf(element);
+    if (index < 0) return false;
+    if (index === 0) {
+      this.poll();
+    } else if (index === this.elements.length - 1) {
+      this.elements.pop();
+    } else {
+      this.elements.splice(index, 1, this.elements.pop());
+      this._bubbleUp(index);
+      this._sinkDown(index, this.elements.length >> 1);
+    }
+    return true;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(log n)
+   *
+   * Depth-first search (DFS) method, different traversal orders can be selected。
+   * @param order - Traverse order parameter: 'IN' (in-order), 'PRE' (pre-order) or 'POST' (post-order).
+   * @returns An array containing elements traversed in the specified order.
+   */
+  dfs(order = "PRE") {
+    const result = [];
+    const _dfs = (index) => {
+      const left = 2 * index + 1, right = left + 1;
+      if (index < this.size) {
+        if (order === "IN") {
+          _dfs(left);
+          result.push(this.elements[index]);
+          _dfs(right);
+        } else if (order === "PRE") {
+          result.push(this.elements[index]);
+          _dfs(left);
+          _dfs(right);
+        } else if (order === "POST") {
+          _dfs(left);
+          _dfs(right);
+          result.push(this.elements[index]);
+        }
+      }
+    };
+    _dfs(0);
+    return result;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * Clone the heap, creating a new heap with the same elements.
+   * @returns A new Heap instance containing the same elements.
+   */
+  clone() {
+    return new _Heap(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+  }
+  /**
+   * Time Complexity: O(n log n)
+   * Space Complexity: O(n)
+   *
+   * Sort the elements in the heap and return them as an array.
+   * @returns An array containing the elements sorted in ascending order.
+   */
+  sort() {
+    const visitedNode = [];
+    const cloned = new _Heap(this, { comparator: this.comparator });
+    while (cloned.size !== 0) {
+      const top = cloned.poll();
+      if (top !== void 0) visitedNode.push(top);
+    }
+    return visitedNode;
+  }
+  /**
+   * Time Complexity: O(n log n)
+   * Space Complexity: O(n)
+   *
+   * Fix the entire heap to maintain heap properties.
+   */
+  fix() {
+    const results = [];
+    for (let i = Math.floor(this.size / 2); i >= 0; i--) results.push(this._sinkDown(i, this.elements.length >> 1));
+    return results;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function creates a new Heap object containing elements that pass a given callback
+   * function.
+   * @param callback - The `callback` parameter is a function that will be called for each element in
+   * the heap. It takes three arguments: the current element, the index of the current element, and the
+   * heap itself. The callback function should return a boolean value indicating whether the current
+   * element should be included in the filtered list
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+   * passed as the `this` value to the `callback` function. If `thisArg` is
+   * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
+   * the filter condition specified by the `callback` function.
+   */
+  filter(callback, thisArg) {
+    const filteredList = new _Heap([], { toElementFn: this.toElementFn, comparator: this.comparator });
+    let index = 0;
+    for (const current of this) {
+      if (callback.call(thisArg, current, index, this)) {
+        filteredList.add(current);
+      }
+      index++;
+    }
+    return filteredList;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function creates a new heap by applying a callback function to each element of the
+   * original heap.
+   * @param callback - The `callback` parameter is a function that will be called for each element in
+   * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
+   * element), and `this` (the heap itself). The callback function should return a value of
+   * @param comparator - The `comparator` parameter is a function that defines the order of the
+   * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
+   * if `a` should be placed before `b`, a positive number if `a` should be placed after
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
+   * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
+   * returns a value of type `T`. This function is used to transform the elements of the original
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the callback function. It is used to set the context or scope
+   * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+   * value of
+   * @returns a new instance of the `Heap` class with the mapped elements.
+   */
+  map(callback, comparator, toElementFn, thisArg) {
+    const mappedHeap = new _Heap([], { comparator, toElementFn });
+    let index = 0;
+    for (const el of this) {
+      mappedHeap.add(callback.call(thisArg, el, index, this));
+      index++;
+    }
+    return mappedHeap;
+  }
+  _DEFAULT_COMPARATOR = (a, b) => {
+    if (typeof a === "object" || typeof b === "object") {
+      throw TypeError(
+        `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+      );
+    }
+    if (a > b) return 1;
+    if (a < b) return -1;
+    return 0;
+  };
+  _comparator = this._DEFAULT_COMPARATOR;
+  /**
+   * The function returns the value of the _comparator property.
+   * @returns The `_comparator` property is being returned.
+   */
+  get comparator() {
+    return this._comparator;
+  }
+  /**
+   * The function `_getIterator` returns an iterable iterator for the elements in the class.
+   */
+  *_getIterator() {
+    for (const element of this.elements) {
+      yield element;
+    }
+  }
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * Float operation to maintain heap properties after adding an element.
+   * @param index - The index of the newly added element.
+   */
+  _bubbleUp(index) {
+    const element = this.elements[index];
+    while (index > 0) {
+      const parent = index - 1 >> 1;
+      const parentItem = this.elements[parent];
+      if (this.comparator(parentItem, element) <= 0) break;
+      this.elements[index] = parentItem;
+      index = parent;
+    }
+    this.elements[index] = element;
+    return true;
+  }
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * Sinking operation to maintain heap properties after removing the top element.
+   * @param index - The index from which to start sinking.
+   * @param halfLength
+   */
+  _sinkDown(index, halfLength) {
+    const element = this.elements[index];
+    while (index < halfLength) {
+      let left = index << 1 | 1;
+      const right = left + 1;
+      let minItem = this.elements[left];
+      if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
+        left = right;
+        minItem = this.elements[right];
+      }
+      if (this.comparator(minItem, element) >= 0) break;
+      this.elements[index] = minItem;
+      index = left;
+    }
+    this.elements[index] = element;
+    return true;
+  }
+};
+
+// 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/graph/abstract-graph.ts
+var AbstractVertex = class {
+  key;
+  value;
+  /**
+   * The function is a protected constructor that takes an key and an optional value as parameters.
+   * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
+   * used to uniquely identify the vertex object.
+   * @param {V} [value] - The parameter "value" is an optional parameter of type V. It is used to assign a value to the
+   * vertex. If no value is provided, it will be set to undefined.
+   */
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+  }
+};
+var AbstractEdge = class {
+  value;
+  weight;
+  /**
+   * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
+   * object.
+   * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the object. If
+   * a value is provided, it will be assigned to the `_weight` property. If no value is provided, the default value of 1
+   * will be assigned.
+   * @param {VO} [value] - The `value` parameter is of type `VO`, which means it can be any type. It is an optional parameter,
+   * meaning it can be omitted when creating an instance of the class.
+   */
+  constructor(weight, value) {
+    this.weight = weight !== void 0 ? weight : 1;
+    this.value = value;
+    this._hashCode = uuidV4();
+  }
+  _hashCode;
+  get hashCode() {
+    return this._hashCode;
+  }
+  /**
+   * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
+   * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
+   */
+};
+var AbstractGraph = class extends IterableEntryBase {
+  constructor() {
+    super();
+  }
+  _vertexMap = /* @__PURE__ */ new Map();
+  get vertexMap() {
+    return this._vertexMap;
+  }
+  set vertexMap(v) {
+    this._vertexMap = v;
+  }
+  get size() {
+    return this._vertexMap.size;
+  }
+  /**
+   * Time Complexity: O(1) - Constant time for Map lookup.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+   *
+   * The function "getVertex" returns the vertex with the specified ID or undefined if it doesn't exist.
+   * @param {VertexKey} vertexKey - The `vertexKey` parameter is the identifier of the vertex that you want to retrieve from
+   * the `_vertexMap` map.
+   * @returns The method `getVertex` returns the vertex with the specified `vertexKey` if it exists in the `_vertexMap`
+   * map. If the vertex does not exist, it returns `undefined`.
+   */
+  getVertex(vertexKey) {
+    return this._vertexMap.get(vertexKey) || void 0;
+  }
+  /**
+   * Time Complexity: O(1) - Constant time for Map lookup.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+   *
+   * The function checks if a vertex exists in a graph.
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+   * (`VertexKey`).
+   * @returns a boolean value.
+   */
+  hasVertex(vertexOrKey) {
+    return this._vertexMap.has(this._getVertexKey(vertexOrKey));
+  }
+  /**
+   * Time Complexity: O(1) - Constant time for Map operations.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+   */
+  addVertex(keyOrVertex, value) {
+    if (keyOrVertex instanceof AbstractVertex) {
+      return this._addVertex(keyOrVertex);
+    } else {
+      const newVertex = this.createVertex(keyOrVertex, value);
+      return this._addVertex(newVertex);
+    }
+  }
+  isVertexKey(potentialKey) {
+    const potentialKeyType = typeof potentialKey;
+    return potentialKeyType === "string" || potentialKeyType === "number";
+  }
+  /**
+   * Time Complexity: O(K), where K is the number of vertexMap to be removed.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+   *
+   * The function removes all vertexMap from a graph and returns a boolean indicating if any vertexMap were removed.
+   * @param {VO[] | VertexKey[]} vertexMap - The `vertexMap` parameter can be either an array of vertexMap (`VO[]`) or an array
+   * of vertex IDs (`VertexKey[]`).
+   * @returns a boolean value. It returns true if at least one vertex was successfully removed, and false if no vertexMap
+   * were removed.
+   */
+  removeManyVertices(vertexMap) {
+    const removed = [];
+    for (const v of vertexMap) {
+      removed.push(this.deleteVertex(v));
+    }
+    return removed.length > 0;
+  }
+  /**
+   * Time Complexity: O(1) - Depends on the implementation in the concrete class.
+   * Space Complexity: O(1) - Depends on the implementation in the concrete class.
+   *
+   * The function checks if there is an edge between two vertexMap and returns a boolean value indicating the result.
+   * @param {VertexKey | VO} v1 - The parameter v1 can be either a VertexKey or a VO. A VertexKey represents the unique
+   * identifier of a vertex in a graph, while VO represents the type of the vertex object itself.
+   * @param {VertexKey | VO} v2 - The parameter `v2` represents the second vertex in the edge. It can be either a
+   * `VertexKey` or a `VO` type, which represents the type of the vertex.
+   * @returns A boolean value is being returned.
+   */
+  hasEdge(v1, v2) {
+    const edge = this.getEdge(v1, v2);
+    return !!edge;
+  }
+  /**
+   * Time Complexity: O(1) - Depends on the implementation in the concrete class.
+   * Space Complexity: O(1) - Depends on the implementation in the concrete class.
+   */
+  addEdge(srcOrEdge, dest, weight, value) {
+    if (srcOrEdge instanceof AbstractEdge) {
+      return this._addEdge(srcOrEdge);
+    } else {
+      if (dest instanceof AbstractVertex || typeof dest === "string" || typeof dest === "number") {
+        if (!(this.hasVertex(srcOrEdge) && this.hasVertex(dest))) return false;
+        if (srcOrEdge instanceof AbstractVertex) srcOrEdge = srcOrEdge.key;
+        if (dest instanceof AbstractVertex) dest = dest.key;
+        const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
+        return this._addEdge(newEdge);
+      } else {
+        throw new Error("dest must be a Vertex or vertex key while srcOrEdge is an Edge");
+      }
+    }
+  }
+  /**
+   * Time Complexity: O(1) - Constant time for Map and Edge operations.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+   *
+   * The function sets the weight of an edge between two vertexMap in a graph.
+   * @param {VertexKey | VO} srcOrKey - The `srcOrKey` parameter can be either a `VertexKey` or a `VO` object. It represents
+   * the source vertex of the edge.
+   * @param {VertexKey | VO} destOrKey - The `destOrKey` parameter represents the destination vertex of the edge. It can be
+   * either a `VertexKey` or a vertex object `VO`.
+   * @param {number} weight - The weight parameter represents the weight of the edge between the source vertex (srcOrKey)
+   * and the destination vertex (destOrKey).
+   * @returns a boolean value. If the edge exists between the source and destination vertexMap, the function will update
+   * the weight of the edge and return true. If the edge does not exist, the function will return false.
+   */
+  setEdgeWeight(srcOrKey, destOrKey, weight) {
+    const edge = this.getEdge(srcOrKey, destOrKey);
+    if (edge) {
+      edge.weight = weight;
+      return true;
+    } else {
+      return false;
+    }
+  }
+  /**
+   * Time Complexity: O(P), where P is the number of paths found (in the worst case, exploring all paths).
+   * Space Complexity: O(P) - Linear space, where P is the number of paths found.
+   *
+   * The function `getAllPathsBetween` finds all paths between two vertexMap in a graph using depth-first search.
+   * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+   * It is the starting vertex for finding paths.
+   * @param {VO | VertexKey} v2 - The parameter `v2` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+   * @param limit - The count of limitation of result array.
+   * @returns The function `getAllPathsBetween` returns an array of arrays of vertexMap (`VO[][]`).
+   */
+  getAllPathsBetween(v1, v2, limit = 1e3) {
+    const paths = [];
+    const vertex1 = this._getVertex(v1);
+    const vertex2 = this._getVertex(v2);
+    if (!(vertex1 && vertex2)) {
+      return [];
+    }
+    const stack = [];
+    stack.push({ vertex: vertex1, path: [vertex1] });
+    while (stack.length > 0) {
+      const { vertex, path } = stack.pop();
+      if (vertex === vertex2) {
+        paths.push(path);
+        if (paths.length >= limit) return paths;
+      }
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        if (!path.includes(neighbor)) {
+          const newPath = [...path, neighbor];
+          stack.push({ vertex: neighbor, path: newPath });
+        }
+      }
+    }
+    return paths;
+  }
+  /**
+   * Time Complexity: O(L), where L is the length of the path.
+   * Space Complexity: O(1) - Constant space.
+   *
+   * The function calculates the sum of weights along a given path.
+   * @param {VO[]} path - An array of vertexMap (VO) representing a path in a graph.
+   * @returns The function `getPathSumWeight` returns the sum of the weights of the edgeMap in the given path.
+   */
+  getPathSumWeight(path) {
+    let sum = 0;
+    for (let i = 0; i < path.length; i++) {
+      sum += this.getEdge(path[i], path[i + 1])?.weight || 0;
+    }
+    return sum;
+  }
+  /**
+   * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
+   * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
+   *
+   * The function `getMinCostBetween` calculates the minimum cost between two vertexMap in a graph, either based on edge
+   * weights or using a breadth-first search algorithm.
+   * @param {VO | VertexKey} v1 - The parameter `v1` represents the starting vertex or its ID.
+   * @param {VO | VertexKey} v2 - The parameter `v2` represents the destination vertex or its ID. It is the vertex to which
+   * you want to find the minimum cost or weight from the source vertex `v1`.
+   * @param {boolean} [isWeight] - isWeight is an optional parameter that indicates whether the graph edgeMap have weights.
+   * If isWeight is set to true, the function will calculate the minimum cost between v1 and v2 based on the weights of
+   * the edgeMap. If isWeight is set to false or not provided, the function will calculate the
+   * @returns The function `getMinCostBetween` returns a number representing the minimum cost between two vertexMap (`v1`
+   * and `v2`). If the `isWeight` parameter is `true`, it calculates the minimum weight among all paths between the
+   * vertexMap. If `isWeight` is `false` or not provided, it uses a breadth-first search (BFS) algorithm to calculate the
+   * minimum number of
+   */
+  getMinCostBetween(v1, v2, isWeight) {
+    if (isWeight === void 0) isWeight = false;
+    if (isWeight) {
+      const allPaths = this.getAllPathsBetween(v1, v2);
+      let min = Number.MAX_SAFE_INTEGER;
+      for (const path of allPaths) {
+        min = Math.min(this.getPathSumWeight(path), min);
+      }
+      return min;
+    } else {
+      const vertex2 = this._getVertex(v2);
+      const vertex1 = this._getVertex(v1);
+      if (!(vertex1 && vertex2)) {
+        return void 0;
+      }
+      const visited = /* @__PURE__ */ new Map();
+      const queue = new Queue([vertex1]);
+      visited.set(vertex1, true);
+      let cost = 0;
+      while (queue.length > 0) {
+        for (let i = 0; i < queue.length; i++) {
+          const cur = queue.shift();
+          if (cur === vertex2) {
+            return cost;
+          }
+          if (cur !== void 0) {
+            const neighbors = this.getNeighbors(cur);
+            for (const neighbor of neighbors) {
+              if (!visited.has(neighbor)) {
+                visited.set(neighbor, true);
+                queue.push(neighbor);
+              }
+            }
+          }
+        }
+        cost++;
+      }
+      return void 0;
+    }
+  }
+  /**
+   * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
+   * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
+   *
+   * The function `getMinPathBetween` returns the minimum path between two vertexMap in a graph, either based on weight or
+   * using a breadth-first search algorithm.
+   * @param {VO | VertexKey} v1 - The parameter `v1` represents the starting vertex of the path. It can be either a vertex
+   * object (`VO`) or a vertex ID (`VertexKey`).
+   * @param {VO | VertexKey} v2 - VO | VertexKey - The second vertex or vertex ID between which we want to find the minimum
+   * path.
+   * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edgeMap in finding the
+   * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
+   * to false, the function will use breadth-first search (BFS) to find the minimum path.
+   * @param isDFS - If set to true, it enforces the use of getAllPathsBetween to first obtain all possible paths,
+   * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
+   * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
+   * @returns The function `getMinPathBetween` returns an array of vertexMap (`VO[]`) representing the minimum path between
+   * two vertexMap (`v1` and `v2`). If there is no path between the vertexMap, it returns `undefined`.
+   */
+  getMinPathBetween(v1, v2, isWeight, isDFS = false) {
+    if (isWeight === void 0) isWeight = false;
+    if (isWeight) {
+      if (isDFS) {
+        const allPaths = this.getAllPathsBetween(v1, v2, 1e4);
+        let min = Number.MAX_SAFE_INTEGER;
+        let minIndex = -1;
+        let index = 0;
+        for (const path of allPaths) {
+          const pathSumWeight = this.getPathSumWeight(path);
+          if (pathSumWeight < min) {
+            min = pathSumWeight;
+            minIndex = index;
+          }
+          index++;
+        }
+        return allPaths[minIndex] || void 0;
+      } else {
+        return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
+      }
+    } else {
+      let minPath = [];
+      const vertex1 = this._getVertex(v1);
+      const vertex2 = this._getVertex(v2);
+      if (!(vertex1 && vertex2)) return [];
+      const dfs = (cur, dest, visiting, path) => {
+        visiting.add(cur);
+        if (cur === dest) {
+          minPath = [vertex1, ...path];
+          return;
+        }
+        const neighbors = this.getNeighbors(cur);
+        for (const neighbor of neighbors) {
+          if (!visiting.has(neighbor)) {
+            path.push(neighbor);
+            dfs(neighbor, dest, visiting, path);
+            path.pop();
+          }
+        }
+        visiting.delete(cur);
+      };
+      dfs(vertex1, vertex2, /* @__PURE__ */ new Set(), []);
+      return minPath;
+    }
+  }
+  /**
+   * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
+   * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
+   *
+   * The function `dijkstraWithoutHeap` implements Dijkstra's algorithm to find the shortest path between two vertexMap in
+   * a graph without using a heap data structure.
+   * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
+   * vertex object or a vertex ID.
+   * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+   * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
+   * identifier. If no destination is provided, the value is set to `undefined`.
+   * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+   * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+   * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+   * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+   * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+   * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
+   * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
+   */
+  dijkstraWithoutHeap(src, dest = void 0, getMinDist = false, genPaths = false) {
+    let minDist = Number.MAX_SAFE_INTEGER;
+    let minDest = void 0;
+    let minPath = [];
+    const paths = [];
+    const vertexMap = this._vertexMap;
+    const distMap = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
+    const preMap = /* @__PURE__ */ new Map();
+    const srcVertex = this._getVertex(src);
+    const destVertex = dest ? this._getVertex(dest) : void 0;
+    if (!srcVertex) {
+      return void 0;
+    }
+    for (const vertex of vertexMap) {
+      const vertexOrKey = vertex[1];
+      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
+    }
+    distMap.set(srcVertex, 0);
+    preMap.set(srcVertex, void 0);
+    const getMinOfNoSeen = () => {
+      let min = Number.MAX_SAFE_INTEGER;
+      let minV = void 0;
+      for (const [key, value] of distMap) {
+        if (!seen.has(key)) {
+          if (value < min) {
+            min = value;
+            minV = key;
+          }
+        }
+      }
+      return minV;
+    };
+    const getPaths = (minV) => {
+      for (const vertex of vertexMap) {
+        const vertexOrKey = vertex[1];
+        if (vertexOrKey instanceof AbstractVertex) {
+          const path = [vertexOrKey];
+          let parent = preMap.get(vertexOrKey);
+          while (parent) {
+            path.push(parent);
+            parent = preMap.get(parent);
+          }
+          const reversed = path.reverse();
+          if (vertex[1] === minV) minPath = reversed;
+          paths.push(reversed);
+        }
+      }
+    };
+    for (let i = 1; i < vertexMap.size; i++) {
+      const cur = getMinOfNoSeen();
+      if (cur) {
+        seen.add(cur);
+        if (destVertex && destVertex === cur) {
+          if (getMinDist) {
+            minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
+          }
+          if (genPaths) {
+            getPaths(destVertex);
+          }
+          return { distMap, preMap, seen, paths, minDist, minPath };
+        }
+        const neighbors = this.getNeighbors(cur);
+        for (const neighbor of neighbors) {
+          if (!seen.has(neighbor)) {
+            const edge = this.getEdge(cur, neighbor);
+            if (edge) {
+              const curFromMap = distMap.get(cur);
+              const neighborFromMap = distMap.get(neighbor);
+              if (curFromMap !== void 0 && neighborFromMap !== void 0) {
+                if (edge.weight + curFromMap < neighborFromMap) {
+                  distMap.set(neighbor, edge.weight + curFromMap);
+                  preMap.set(neighbor, cur);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (getMinDist)
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < minDist) {
+            minDist = d;
+            if (genPaths) minDest = v;
+          }
+        }
+      });
+    if (genPaths) getPaths(minDest);
+    return { distMap, preMap, seen, paths, minDist, minPath };
+  }
+  /**
+   * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
+   * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
+   *
+   * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
+   * The `dijkstra` function implements Dijkstra's algorithm to find the shortest path between a source vertex and an
+   * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
+   * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
+   * start. It can be either a vertex object or a vertex ID.
+   * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+   * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
+   * will calculate the shortest paths to all other vertexMap from the source vertex.
+   * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+   * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+   * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+   * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+   * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+   * shortest paths from the source vertex to all other vertexMap in the graph. If `genPaths
+   * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
+   */
+  dijkstra(src, dest = void 0, getMinDist = false, genPaths = false) {
+    let minDist = Number.MAX_SAFE_INTEGER;
+    let minDest = void 0;
+    let minPath = [];
+    const paths = [];
+    const vertexMap = this._vertexMap;
+    const distMap = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
+    const preMap = /* @__PURE__ */ new Map();
+    const srcVertex = this._getVertex(src);
+    const destVertex = dest ? this._getVertex(dest) : void 0;
+    if (!srcVertex) return void 0;
+    for (const vertex of vertexMap) {
+      const vertexOrKey = vertex[1];
+      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
+    }
+    const heap = new Heap([], { comparator: (a, b) => a.key - b.key });
+    heap.add({ key: 0, value: srcVertex });
+    distMap.set(srcVertex, 0);
+    preMap.set(srcVertex, void 0);
+    const getPaths = (minV) => {
+      for (const vertex of vertexMap) {
+        const vertexOrKey = vertex[1];
+        if (vertexOrKey instanceof AbstractVertex) {
+          const path = [vertexOrKey];
+          let parent = preMap.get(vertexOrKey);
+          while (parent) {
+            path.push(parent);
+            parent = preMap.get(parent);
+          }
+          const reversed = path.reverse();
+          if (vertex[1] === minV) minPath = reversed;
+          paths.push(reversed);
+        }
+      }
+    };
+    while (heap.size > 0) {
+      const curHeapNode = heap.poll();
+      const dist = curHeapNode?.key;
+      const cur = curHeapNode?.value;
+      if (dist !== void 0) {
+        if (cur) {
+          seen.add(cur);
+          if (destVertex && destVertex === cur) {
+            if (getMinDist) {
+              minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
+            }
+            if (genPaths) {
+              getPaths(destVertex);
+            }
+            return { distMap, preMap, seen, paths, minDist, minPath };
+          }
+          const neighbors = this.getNeighbors(cur);
+          for (const neighbor of neighbors) {
+            if (!seen.has(neighbor)) {
+              const weight = this.getEdge(cur, neighbor)?.weight;
+              if (typeof weight === "number") {
+                const distSrcToNeighbor = distMap.get(neighbor);
+                if (distSrcToNeighbor) {
+                  if (dist + weight < distSrcToNeighbor) {
+                    heap.add({ key: dist + weight, value: neighbor });
+                    preMap.set(neighbor, cur);
+                    distMap.set(neighbor, dist + weight);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (getMinDist) {
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < minDist) {
+            minDist = d;
+            if (genPaths) minDest = v;
+          }
+        }
+      });
+    }
+    if (genPaths) {
+      getPaths(minDest);
+    }
+    return { distMap, preMap, seen, paths, minDist, minPath };
+  }
+  /**
+   * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
+   * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
+   *
+   * one to rest pairs
+   * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edgeMap for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edgeMap, the Bellman-Ford algorithm is more flexible in some scenarios.
+   * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+   * all other vertexMap in a graph, and optionally detects negative cycles and generates the minimum path.
+   * @param {VO | VertexKey} src - The `src` parameter is the source vertex from which the Bellman-Ford algorithm will
+   * start calculating the shortest paths. It can be either a vertex object or a vertex ID.
+   * @param {boolean} [scanNegativeCycle] - A boolean flag indicating whether to scan for negative cycles in the graph.
+   * @param {boolean} [getMin] - The `getMin` parameter is a boolean flag that determines whether the algorithm should
+   * calculate the minimum distance from the source vertex to all other vertexMap in the graph. If `getMin` is set to
+   * `true`, the algorithm will find the minimum distance and update the `min` variable with the minimum
+   * @param {boolean} [genPath] - A boolean flag indicating whether to generate paths for all vertexMap from the source
+   * vertex.
+   * @returns The function `bellmanFord` returns an object with the following properties:
+   */
+  bellmanFord(src, scanNegativeCycle, getMin, genPath) {
+    if (getMin === void 0) getMin = false;
+    if (genPath === void 0) genPath = false;
+    const srcVertex = this._getVertex(src);
+    const paths = [];
+    const distMap = /* @__PURE__ */ new Map();
+    const preMap = /* @__PURE__ */ new Map();
+    let min = Number.MAX_SAFE_INTEGER;
+    let minPath = [];
+    let hasNegativeCycle;
+    if (scanNegativeCycle) hasNegativeCycle = false;
+    if (!srcVertex) return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
+    const vertexMap = this._vertexMap;
+    const numOfVertices = vertexMap.size;
+    const edgeMap = this.edgeSet();
+    const numOfEdges = edgeMap.length;
+    this._vertexMap.forEach((vertex) => {
+      distMap.set(vertex, Number.MAX_SAFE_INTEGER);
+    });
+    distMap.set(srcVertex, 0);
+    for (let i = 1; i < numOfVertices; ++i) {
+      for (let j = 0; j < numOfEdges; ++j) {
+        const ends = this.getEndsOfEdge(edgeMap[j]);
+        if (ends) {
+          const [s, d] = ends;
+          const weight = edgeMap[j].weight;
+          const sWeight = distMap.get(s);
+          const dWeight = distMap.get(d);
+          if (sWeight !== void 0 && dWeight !== void 0) {
+            if (distMap.get(s) !== Number.MAX_SAFE_INTEGER && sWeight + weight < dWeight) {
+              distMap.set(d, sWeight + weight);
+              if (genPath) preMap.set(d, s);
+            }
+          }
+        }
+      }
+    }
+    let minDest = void 0;
+    if (getMin) {
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < min) {
+            min = d;
+            if (genPath) minDest = v;
+          }
+        }
+      });
+    }
+    if (genPath) {
+      for (const vertex of vertexMap) {
+        const vertexOrKey = vertex[1];
+        if (vertexOrKey instanceof AbstractVertex) {
+          const path = [vertexOrKey];
+          let parent = preMap.get(vertexOrKey);
+          while (parent !== void 0) {
+            path.push(parent);
+            parent = preMap.get(parent);
+          }
+          const reversed = path.reverse();
+          if (vertex[1] === minDest) minPath = reversed;
+          paths.push(reversed);
+        }
+      }
+    }
+    for (let j = 0; j < numOfEdges; ++j) {
+      const ends = this.getEndsOfEdge(edgeMap[j]);
+      if (ends) {
+        const [s] = ends;
+        const weight = edgeMap[j].weight;
+        const sWeight = distMap.get(s);
+        if (sWeight) {
+          if (sWeight !== Number.MAX_SAFE_INTEGER && sWeight + weight < sWeight) hasNegativeCycle = true;
+        }
+      }
+    }
+    return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
+  }
+  /**
+   * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
+   */
+  /**
+   * Dijkstra algorithm time: O(logVE) space: O(VO + EO)
+   * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
+   */
+  /**
+   * BellmanFord time:O(VE) space:O(VO)
+   * one to rest pairs
+   * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edgeMap for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edgeMap, the Bellman-Ford algorithm is more flexible in some scenarios.
+   * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+   */
+  /**
+   * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
+   * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
+   *
+   * Not support graph with negative weight cycle
+   * all pairs
+   * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
+   * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertexMap in a
+   * graph.
+   * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
+   * property is a 2D array of numbers representing the shortest path costs between vertexMap in a graph. The
+   * `predecessor` property is a 2D array of vertexMap (or `undefined`) representing the predecessor vertexMap in the shortest
+   * path between vertexMap in the
+   */
+  floydWarshall() {
+    const idAndVertices = [...this._vertexMap];
+    const n = idAndVertices.length;
+    const costs = [];
+    const predecessor = [];
+    for (let i = 0; i < n; i++) {
+      costs[i] = [];
+      predecessor[i] = [];
+      for (let j = 0; j < n; j++) {
+        predecessor[i][j] = void 0;
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        costs[i][j] = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])?.weight || Number.MAX_SAFE_INTEGER;
+      }
+    }
+    for (let k = 0; k < n; k++) {
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          if (costs[i][j] > costs[i][k] + costs[k][j]) {
+            costs[i][j] = costs[i][k] + costs[k][j];
+            predecessor[i][j] = idAndVertices[k][1];
+          }
+        }
+      }
+    }
+    return { costs, predecessor };
+  }
+  /**
+   * O(V+E+C)
+   * O(V+C)
+   */
+  getCycles(isInclude2Cycle = false) {
+    const cycles = [];
+    const visited = /* @__PURE__ */ new Set();
+    const dfs = (vertex, currentPath, visited2) => {
+      if (visited2.has(vertex)) {
+        if ((!isInclude2Cycle && currentPath.length > 2 || isInclude2Cycle && currentPath.length >= 2) && currentPath[0] === vertex.key) {
+          cycles.push([...currentPath]);
+        }
+        return;
+      }
+      visited2.add(vertex);
+      currentPath.push(vertex.key);
+      for (const neighbor of this.getNeighbors(vertex)) {
+        if (neighbor) dfs(neighbor, currentPath, visited2);
+      }
+      visited2.delete(vertex);
+      currentPath.pop();
+    };
+    for (const vertex of this.vertexMap.values()) {
+      dfs(vertex, [], visited);
+    }
+    const uniqueCycles = /* @__PURE__ */ new Map();
+    for (const cycle of cycles) {
+      const sorted = [...cycle].sort().toString();
+      if (uniqueCycles.has(sorted)) continue;
+      else {
+        uniqueCycles.set(sorted, cycle);
+      }
+    }
+    return [...uniqueCycles].map((cycleString) => cycleString[1]);
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function iterates over key-value pairs in a data structure and returns an array of
+   * pairs that satisfy a given predicate.
+   * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+   * `value`, `key`, `index`, and `this`. It is used to determine whether an element should be included
+   * in the filtered array. The callback function should return `true` if the element should be
+   * included, and `
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+   * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
+   * @returns The `filter` method returns an array of key-value pairs `[VertexKey, V | undefined][]`
+   * that satisfy the given predicate function.
+   */
+  filter(predicate, thisArg) {
+    const filtered = [];
+    let index = 0;
+    for (const [key, value] of this) {
+      if (predicate.call(thisArg, key, value, index, this)) {
+        filtered.push([key, value]);
+      }
+      index++;
+    }
+    return filtered;
+  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function iterates over the elements of a collection and applies a callback function to
+   * each element, returning an array of the results.
+   * @param callback - The callback parameter is a function that will be called for each element in the
+   * map. It takes four arguments:
+   * @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, `
+   * @returns The `map` function is returning an array of type `T[]`.
+   */
+  map(callback, thisArg) {
+    const mapped = [];
+    let index = 0;
+    for (const [key, value] of this) {
+      mapped.push(callback.call(thisArg, key, value, index, this));
+      index++;
+    }
+    return mapped;
+  }
+  *_getIterator() {
+    for (const vertex of this._vertexMap.values()) {
+      yield [vertex.key, vertex.value];
+    }
+  }
+  _addVertex(newVertex) {
+    if (this.hasVertex(newVertex)) {
+      return false;
+    }
+    this._vertexMap.set(newVertex.key, newVertex);
+    return true;
+  }
+  _getVertex(vertexOrKey) {
+    const vertexKey = this._getVertexKey(vertexOrKey);
+    return this._vertexMap.get(vertexKey) || void 0;
+  }
+  _getVertexKey(vertexOrKey) {
+    return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
+  }
+};
+
+// src/data-structures/graph/directed-graph.ts
+var DirectedVertex = class extends AbstractVertex {
+  /**
+   * The constructor function initializes a vertex with an optional value.
+   * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
+   * used to uniquely identify the vertex within a graph or data structure.
+   * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
+   * vertex. If no value is provided, the vertex will be initialized with a default value.
+   */
+  constructor(key, value) {
+    super(key, value);
+  }
+};
+var DirectedEdge = class extends AbstractEdge {
+  src;
+  dest;
+  /**
+   * The constructor function initializes the source and destination vertexMap of an edge, along with an optional weight
+   * and value.
+   * @param {VertexKey} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+   * a graph.
+   * @param {VertexKey} dest - The `dest` parameter represents the destination vertex of an edge. It is of type
+   * `VertexKey`, which is likely a unique identifier for a vertex in a graph.
+   * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
+   * @param {E} [value] - The `value` parameter is an optional parameter of type `E`. It represents the value associated with
+   * the edge.
+   */
+  constructor(src, dest, weight, value) {
+    super(weight, value);
+    this.src = src;
+    this.dest = dest;
+  }
+};
+var DirectedGraph = class _DirectedGraph extends AbstractGraph {
+  /**
+   * The constructor function initializes an instance of a class.
+   */
+  constructor() {
+    super();
+  }
+  _outEdgeMap = /* @__PURE__ */ new Map();
+  get outEdgeMap() {
+    return this._outEdgeMap;
+  }
+  set outEdgeMap(v) {
+    this._outEdgeMap = v;
+  }
+  _inEdgeMap = /* @__PURE__ */ new Map();
+  get inEdgeMap() {
+    return this._inEdgeMap;
+  }
+  set inEdgeMap(v) {
+    this._inEdgeMap = v;
+  }
+  /**
+   * The function creates a new vertex with an optional value and returns it.
+   * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is of type `VertexKey`, which
+   * could be a number or a string depending on how you want to identify your vertexMap.
+   * @param [value] - The 'value' parameter is an optional value that can be assigned to the vertex. If a value is provided,
+   * it will be assigned to the 'value' property of the vertex. If no value is provided, the 'value' property will be
+   * assigned the same value as the 'key' parameter
+   * @returns a new instance of a DirectedVertex object, casted as type VO.
+   */
+  createVertex(key, value) {
+    return new DirectedVertex(key, value);
+  }
+  /**
+   * The function creates a directed edge between two vertexMap with an optional weight and value.
+   * @param {VertexKey} src - The source vertex ID of the edge. It represents the starting point of the edge.
+   * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for the edge.
+   * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge. If no
+   * weight is provided, it defaults to 1.
+   * @param [value] - The 'value' parameter is an optional value that can be assigned to the edge. It can be of any type and
+   * is used to store additional information or data associated with the edge.
+   * @returns a new instance of a DirectedEdge object, casted as type EO.
+   */
+  createEdge(src, dest, weight, value) {
+    return new DirectedEdge(src, dest, weight ?? 1, value);
+  }
+  /**
+   * Time Complexity: O(|V|) where |V| is the number of vertexMap
+   * Space Complexity: O(1)
+   *
+   * The `getEdge` function retrieves an edge between two vertexMap based on their source and destination IDs.
+   * @param {VO | VertexKey | undefined} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+   * @param {VO | VertexKey | undefined} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+   * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `undefined` if the
+   * destination is not specified.
+   * @returns the first edge found between the source and destination vertexMap, or undefined if no such edge is found.
+   */
+  getEdge(srcOrKey, destOrKey) {
+    let edgeMap = [];
+    if (srcOrKey !== void 0 && destOrKey !== void 0) {
+      const src = this._getVertex(srcOrKey);
+      const dest = this._getVertex(destOrKey);
+      if (src && dest) {
+        const srcOutEdges = this._outEdgeMap.get(src);
+        if (srcOutEdges) {
+          edgeMap = srcOutEdges.filter((edge) => edge.dest === dest.key);
+        }
+      }
+    }
+    return edgeMap[0] || void 0;
+  }
+  /**
+   * Time Complexity: O(|E|) where |E| is the number of edgeMap
+   * Space Complexity: O(1)
+   *
+   * The function removes an edge between two vertexMap in a graph and returns the removed edge.
+   * @param {VO | VertexKey} srcOrKey - The source vertex or its ID.
+   * @param {VO | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
+   * @returns the removed edge (EO) if it exists, or undefined if either the source or destination vertex does not exist.
+   */
+  deleteEdgeSrcToDest(srcOrKey, destOrKey) {
+    const src = this._getVertex(srcOrKey);
+    const dest = this._getVertex(destOrKey);
+    let removed = void 0;
+    if (!src || !dest) {
+      return void 0;
+    }
+    const srcOutEdges = this._outEdgeMap.get(src);
+    if (srcOutEdges) {
+      arrayRemove(srcOutEdges, (edge) => edge.dest === dest.key);
+    }
+    const destInEdges = this._inEdgeMap.get(dest);
+    if (destInEdges) {
+      removed = arrayRemove(destInEdges, (edge) => edge.src === src.key)[0] || void 0;
+    }
+    return removed;
+  }
+  /**
+   * Time Complexity: O(E) where E is the number of edgeMap
+   * Space Complexity: O(1)
+   *
+   * The `deleteEdge` function removes an edge from a graph and returns the removed edge.
+   * @param {EO | VertexKey} edgeOrSrcVertexKey - The `edge` parameter can be either an `EO` object (edge object) or
+   * a `VertexKey` (key of a vertex).
+   * @param {VertexKey} [destVertexKey] - The `destVertexKey` parameter is an optional parameter that
+   * represents the key of the destination vertex of the edge. It is used to specify the destination
+   * vertex when the `edge` parameter is a vertex key. If `destVertexKey` is not provided, the function
+   * assumes that the `edge`
+   * @returns the removed edge (EO) or undefined if no edge was removed.
+   */
+  deleteEdge(edgeOrSrcVertexKey, destVertexKey) {
+    let removed = void 0;
+    let src, dest;
+    if (this.isVertexKey(edgeOrSrcVertexKey)) {
+      if (this.isVertexKey(destVertexKey)) {
+        src = this._getVertex(edgeOrSrcVertexKey);
+        dest = this._getVertex(destVertexKey);
+      } else {
+        return;
+      }
+    } else {
+      src = this._getVertex(edgeOrSrcVertexKey.src);
+      dest = this._getVertex(edgeOrSrcVertexKey.dest);
+    }
+    if (src && dest) {
+      const srcOutEdges = this._outEdgeMap.get(src);
+      if (srcOutEdges && srcOutEdges.length > 0) {
+        arrayRemove(srcOutEdges, (edge) => edge.src === src.key && edge.dest === dest?.key);
+      }
+      const destInEdges = this._inEdgeMap.get(dest);
+      if (destInEdges && destInEdges.length > 0) {
+        removed = arrayRemove(destInEdges, (edge) => edge.src === src.key && edge.dest === dest.key)[0];
+      }
+    }
+    return removed;
+  }
+  /**
+   * Time Complexity: O(1) - Constant time for Map operations.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+   *
+   * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+   * (`VertexKey`).
+   * @returns The method is returning a boolean value.
+   */
+  deleteVertex(vertexOrKey) {
+    let vertexKey;
+    let vertex;
+    if (this.isVertexKey(vertexOrKey)) {
+      vertex = this.getVertex(vertexOrKey);
+      vertexKey = vertexOrKey;
+    } else {
+      vertex = vertexOrKey;
+      vertexKey = this._getVertexKey(vertexOrKey);
+    }
+    if (vertex) {
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        this.deleteEdgeSrcToDest(vertex, neighbor);
+      }
+      this._outEdgeMap.delete(vertex);
+      this._inEdgeMap.delete(vertex);
+    }
+    return this._vertexMap.delete(vertexKey);
+  }
+  /**
+   * Time Complexity: O(|E|) where |E| is the number of edgeMap
+   * Space Complexity: O(1)
+   *
+   * The function removes edgeMap between two vertexMap and returns the removed edgeMap.
+   * @param {VertexKey | VO} v1 - The parameter `v1` can be either a `VertexKey` or a `VO`. A `VertexKey` represents the
+   * unique identifier of a vertex in a graph, while `VO` represents the actual vertex object.
+   * @param {VertexKey | VO} v2 - The parameter `v2` represents either a `VertexKey` or a `VO` object. It is used to specify
+   * the second vertex in the edge that needs to be removed.
+   * @returns an array of removed edgeMap (EO[]).
+   */
+  deleteEdgesBetween(v1, v2) {
+    const removed = [];
+    if (v1 && v2) {
+      const v1ToV2 = this.deleteEdgeSrcToDest(v1, v2);
+      const v2ToV1 = this.deleteEdgeSrcToDest(v2, v1);
+      if (v1ToV2) removed.push(v1ToV2);
+      if (v2ToV1) removed.push(v2ToV1);
+    }
+    return removed;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function `incomingEdgesOf` returns an array of incoming edgeMap for a given vertex or vertex ID.
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+   * (`VertexKey`).
+   * @returns The method `incomingEdgesOf` returns an array of edgeMap (`EO[]`).
+   */
+  incomingEdgesOf(vertexOrKey) {
+    const target = this._getVertex(vertexOrKey);
+    if (target) {
+      return this.inEdgeMap.get(target) || [];
+    }
+    return [];
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function `outgoingEdgesOf` returns an array of outgoing edgeMap from a given vertex or vertex ID.
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can accept either a vertex object (`VO`) or a vertex ID
+   * (`VertexKey`).
+   * @returns The method `outgoingEdgesOf` returns an array of edgeMap (`EO[]`).
+   */
+  outgoingEdgesOf(vertexOrKey) {
+    const target = this._getVertex(vertexOrKey);
+    if (target) {
+      return this._outEdgeMap.get(target) || [];
+    }
+    return [];
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function "degreeOf" returns the total degree of a vertex, which is the sum of its out-degree and in-degree.
+   * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
+   * @returns The sum of the out-degree and in-degree of the specified vertex or vertex ID.
+   */
+  degreeOf(vertexOrKey) {
+    return this.outDegreeOf(vertexOrKey) + this.inDegreeOf(vertexOrKey);
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function "inDegreeOf" returns the number of incoming edgeMap for a given vertex.
+   * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
+   * @returns The number of incoming edgeMap of the specified vertex or vertex ID.
+   */
+  inDegreeOf(vertexOrKey) {
+    return this.incomingEdgesOf(vertexOrKey).length;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function `outDegreeOf` returns the number of outgoing edgeMap from a given vertex.
+   * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
+   * @returns The number of outgoing edgeMap from the specified vertex or vertex ID.
+   */
+  outDegreeOf(vertexOrKey) {
+    return this.outgoingEdgesOf(vertexOrKey).length;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function "edgesOf" returns an array of both outgoing and incoming edgeMap of a given vertex or vertex ID.
+   * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
+   * @returns The function `edgesOf` returns an array of edgeMap.
+   */
+  edgesOf(vertexOrKey) {
+    return [...this.outgoingEdgesOf(vertexOrKey), ...this.incomingEdgesOf(vertexOrKey)];
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function "getEdgeSrc" returns the source vertex of an edge, or undefined if the edge does not exist.
+   * @param {EO} e - The parameter "e" is of type EO, which represents an edge in a graph.
+   * @returns either a vertex object (VO) or undefined.
+   */
+  getEdgeSrc(e) {
+    return this._getVertex(e.src);
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function "getEdgeDest" returns the destination vertex of an edge.
+   * @param {EO} e - The parameter "e" is of type "EO", which represents an edge in a graph.
+   * @returns either a vertex object of type VO or undefined.
+   */
+  getEdgeDest(e) {
+    return this._getVertex(e.dest);
+  }
+  /**
+   * Time Complexity: O(|E|) where |E| is the number of edgeMap
+   * Space Complexity: O(1)
+   *
+   * The function `getDestinations` returns an array of destination vertexMap connected to a given vertex.
+   * @param {VO | VertexKey | undefined} vertex - The `vertex` parameter represents the starting vertex from which we want to
+   * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `undefined`.
+   * @returns an array of vertexMap (VO[]).
+   */
+  getDestinations(vertex) {
+    if (vertex === void 0) {
+      return [];
+    }
+    const destinations = [];
+    const outgoingEdges = this.outgoingEdgesOf(vertex);
+    for (const outEdge of outgoingEdges) {
+      const child = this.getEdgeDest(outEdge);
+      if (child) {
+        destinations.push(child);
+      }
+    }
+    return destinations;
+  }
+  /**
+   * Time Complexity: O(|V| + |E|) where |V| is the number of vertexMap and |E| is the number of edgeMap
+   * Space Complexity: O(|V|)
+   *
+   * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertexMap or vertex IDs
+   * in the sorted order, or undefined if the graph contains a cycle.
+   * @param {'vertex' | 'key'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
+   * property to use for sorting the vertexMap. It can have two possible values: 'vertex' or 'key'. If 'vertex' is
+   * specified, the vertexMap themselves will be used for sorting. If 'key' is specified, the ids of
+   * @returns an array of vertexMap or vertex IDs in topological order. If there is a cycle in the graph, it returns undefined.
+   */
+  topologicalSort(propertyName) {
+    propertyName = propertyName ?? "key";
+    const statusMap = /* @__PURE__ */ new Map();
+    for (const entry of this.vertexMap) {
+      statusMap.set(entry[1], 0);
+    }
+    let sorted = [];
+    let hasCycle = false;
+    const dfs = (cur) => {
+      statusMap.set(cur, 1);
+      const children = this.getDestinations(cur);
+      for (const child of children) {
+        const childStatus = statusMap.get(child);
+        if (childStatus === 0) {
+          dfs(child);
+        } else if (childStatus === 1) {
+          hasCycle = true;
+        }
+      }
+      statusMap.set(cur, 2);
+      sorted.push(cur);
+    };
+    for (const entry of this.vertexMap) {
+      if (statusMap.get(entry[1]) === 0) {
+        dfs(entry[1]);
+      }
+    }
+    if (hasCycle) return void 0;
+    if (propertyName === "key") sorted = sorted.map((vertex) => vertex instanceof DirectedVertex ? vertex.key : vertex);
+    return sorted.reverse();
+  }
+  /**
+   * Time Complexity: O(|E|) where |E| is the number of edgeMap
+   * Space Complexity: O(|E|)
+   *
+   * The `edgeSet` function returns an array of all the edgeMap in the graph.
+   * @returns The `edgeSet()` method returns an array of edgeMap (`EO[]`).
+   */
+  edgeSet() {
+    let edgeMap = [];
+    this._outEdgeMap.forEach((outEdges) => {
+      edgeMap = [...edgeMap, ...outEdges];
+    });
+    return edgeMap;
+  }
+  /**
+   * Time Complexity: O(|E|) where |E| is the number of edgeMap
+   * Space Complexity: O(1)
+   *
+   * The function `getNeighbors` returns an array of neighboring vertexMap of a given vertex or vertex ID in a graph.
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+   * (`VertexKey`).
+   * @returns an array of vertexMap (VO[]).
+   */
+  getNeighbors(vertexOrKey) {
+    const neighbors = [];
+    const vertex = this._getVertex(vertexOrKey);
+    if (vertex) {
+      const outEdges = this.outgoingEdgesOf(vertex);
+      for (const outEdge of outEdges) {
+        const neighbor = this._getVertex(outEdge.dest);
+        if (neighbor) {
+          neighbors.push(neighbor);
+        }
+      }
+    }
+    return neighbors;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function "getEndsOfEdge" returns the source and destination vertexMap of an edge if it exists in the graph,
+   * otherwise it returns undefined.
+   * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph.
+   * @returns The function `getEndsOfEdge` returns an array containing two vertexMap `[VO, VO]` if the edge exists in the
+   * graph. If the edge does not exist, it returns `undefined`.
+   */
+  getEndsOfEdge(edge) {
+    if (!this.hasEdge(edge.src, edge.dest)) {
+      return void 0;
+    }
+    const v1 = this._getVertex(edge.src);
+    const v2 = this._getVertex(edge.dest);
+    if (v1 && v2) {
+      return [v1, v2];
+    } else {
+      return void 0;
+    }
+  }
+  /**
+   * The isEmpty function checks if the graph is empty.
+   *
+   * @return A boolean value
+   */
+  isEmpty() {
+    return this.vertexMap.size === 0 && this.inEdgeMap.size === 0 && this.outEdgeMap.size === 0;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The clear function resets the vertex map, in-edge map, and out-edge map.
+   */
+  clear() {
+    this._vertexMap = /* @__PURE__ */ new Map();
+    this._inEdgeMap = /* @__PURE__ */ new Map();
+    this._outEdgeMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
+   *
+   * @return A new instance of the directedgraph class
+   */
+  clone() {
+    const cloned = new _DirectedGraph();
+    cloned.vertexMap = new Map(this.vertexMap);
+    cloned.inEdgeMap = new Map(this.inEdgeMap);
+    cloned.outEdgeMap = new Map(this.outEdgeMap);
+    return cloned;
+  }
+  /**
+   *  Time Complexity: O(V + E)
+   *  Space Complexity: O(V)
+   *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+   *  Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+   *
+   * The function `tarjan` implements the Tarjan's algorithm to find strongly connected components in a
+   * graph.
+   * @returns The function `tarjan()` returns an object with three properties: `dfnMap`, `lowMap`, and
+   * `SCCs`.
+   */
+  tarjan() {
+    const dfnMap = /* @__PURE__ */ new Map();
+    const lowMap = /* @__PURE__ */ new Map();
+    const SCCs = /* @__PURE__ */ new Map();
+    let time = 0;
+    const stack = [];
+    const inStack = /* @__PURE__ */ new Set();
+    const dfs = (vertex) => {
+      dfnMap.set(vertex, time);
+      lowMap.set(vertex, time);
+      time++;
+      stack.push(vertex);
+      inStack.add(vertex);
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        if (!dfnMap.has(neighbor)) {
+          dfs(neighbor);
+          lowMap.set(vertex, Math.min(lowMap.get(vertex), lowMap.get(neighbor)));
+        } else if (inStack.has(neighbor)) {
+          lowMap.set(vertex, Math.min(lowMap.get(vertex), dfnMap.get(neighbor)));
+        }
+      }
+      if (dfnMap.get(vertex) === lowMap.get(vertex)) {
+        const SCC = [];
+        let poppedVertex;
+        do {
+          poppedVertex = stack.pop();
+          inStack.delete(poppedVertex);
+          SCC.push(poppedVertex);
+        } while (poppedVertex !== vertex);
+        SCCs.set(SCCs.size, SCC);
+      }
+    };
+    for (const vertex of this.vertexMap.values()) {
+      if (!dfnMap.has(vertex)) {
+        dfs(vertex);
+      }
+    }
+    return { dfnMap, lowMap, SCCs };
+  }
+  /**
+   * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
+   * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
+   *
+   * The function returns a map that associates each vertex object with its corresponding depth-first
+   * number.
+   * @returns A Map object with keys of type VO and values of type number.
+   */
+  getDFNMap() {
+    return this.tarjan().dfnMap;
+  }
+  /**
+   * The function returns a Map object that contains the low values of each vertex in a Tarjan
+   * algorithm.
+   * @returns The method `getLowMap()` is returning a `Map` object with keys of type `VO` and values of
+   * type `number`.
+   */
+  getLowMap() {
+    return this.tarjan().lowMap;
+  }
+  /**
+   * The function "getSCCs" returns a map of strongly connected components (SCCs) using the Tarjan
+   * algorithm.
+   * @returns a map where the keys are numbers and the values are arrays of VO objects.
+   */
+  getSCCs() {
+    return this.tarjan().SCCs;
+  }
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function `_addEdge` adds an edge to a graph if the source and destination vertexMap exist.
+   * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph. It is the edge that
+   * needs to be added to the graph.
+   * @returns a boolean value. It returns true if the edge was successfully added to the graph, and false if either the
+   * source or destination vertex does not exist in the graph.
+   */
+  _addEdge(edge) {
+    if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
+      return false;
+    }
+    const srcVertex = this._getVertex(edge.src);
+    const destVertex = this._getVertex(edge.dest);
+    if (srcVertex && destVertex) {
+      const srcOutEdges = this._outEdgeMap.get(srcVertex);
+      if (srcOutEdges) {
+        srcOutEdges.push(edge);
+      } else {
+        this._outEdgeMap.set(srcVertex, [edge]);
+      }
+      const destInEdges = this._inEdgeMap.get(destVertex);
+      if (destInEdges) {
+        destInEdges.push(edge);
+      } else {
+        this._inEdgeMap.set(destVertex, [edge]);
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+export {
+  DirectedEdge,
+  DirectedGraph,
+  DirectedVertex
+};
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+/**
+ * data-structure-typed
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+/**
+ * data-structure-typed
+ *
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+/**
+ * @license MIT
+ * @copyright Pablo Zeng <zrwusa@gmail.com>
+ * @class
+ */