priority-queue-typed 2.4.2 → 2.4.4

package/dist/umd/priority-queue-typed.min.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts","../../src/data-structures/base/iterable-element-base.ts","../../src/data-structures/heap/heap.ts","../../src/data-structures/heap/max-heap.ts","../../src/data-structures/heap/min-heap.ts","../../src/data-structures/priority-queue/priority-queue.ts","../../src/data-structures/priority-queue/min-priority-queue.ts","../../src/data-structures/priority-queue/max-priority-queue.ts","../../src/common/index.ts"],"sourcesContent":["/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\nexport * from './data-structures/priority-queue';\nexport * from './data-structures/heap';\nexport * from './types/data-structures/priority-queue';\nexport * from './types/data-structures/heap';\nexport * from './types/common';\nexport * from './types/utils';\nexport * from './common';","import type { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';\n\n/**\n * Base class that makes a data structure iterable and provides common\n * element-wise utilities (e.g., map/filter/reduce/find).\n *\n * @template E The public element type yielded by the structure.\n * @template R The underlying \"raw\" element type used internally or by converters.\n *\n * @remarks\n * This class implements the JavaScript iteration protocol (via `Symbol.iterator`)\n * and offers array-like helpers with predictable time/space complexity.\n */\nexport abstract class IterableElementBase<E, R> implements Iterable<E> {\n  /**\n   * Create a new iterable base.\n   *\n   * @param options Optional behavior overrides. When provided, a `toElementFn`\n   * is used to convert a raw element (`R`) into a public element (`E`).\n   *\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  protected constructor(options?: IterableElementBaseOptions<E, R>) {\n    if (options) {\n      const { toElementFn } = options;\n      if (typeof toElementFn === 'function') this._toElementFn = toElementFn;\n      else if (toElementFn) throw new TypeError('toElementFn must be a function type');\n    }\n  }\n\n  /**\n   * The converter used to transform a raw element (`R`) into a public element (`E`).\n   *\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  protected _toElementFn?: (rawElement: R) => E;\n\n  /**\n   * Exposes the current `toElementFn`, if configured.\n   *\n   * @returns The converter function or `undefined` when not set.\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  get toElementFn(): ((rawElement: R) => E) | undefined {\n    return this._toElementFn;\n  }\n\n  /**\n   * Returns an iterator over the structure's elements.\n   *\n   * @param args Optional iterator arguments forwarded to the internal iterator.\n   * @returns An `IterableIterator<E>` that yields the elements in traversal order.\n   *\n   * @remarks\n   * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.\n   */\n  *[Symbol.iterator](...args: unknown[]): IterableIterator<E> {\n    yield* this._getIterator(...args);\n  }\n\n  /**\n   * Returns an iterator over the values (alias of the default iterator).\n   *\n   * @returns An `IterableIterator<E>` over all elements.\n   * @remarks\n   * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).\n   */\n  *values(): IterableIterator<E> {\n    for (const item of this) yield item;\n  }\n\n  /**\n   * Tests whether all elements satisfy the predicate.\n   *\n   * @template TReturn\n   * @param predicate Function invoked for each element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns `true` if every element passes; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).\n   */\n  every(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (!predicate(item, index++, this)) return false;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (!fn.call(thisArg, item, index++, this)) return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Tests whether at least one element satisfies the predicate.\n   *\n   * @param predicate Function invoked for each element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns `true` if any element passes; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early on first success. Space O(1).\n   */\n  some(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (predicate(item, index++, this)) return true;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (fn.call(thisArg, item, index++, this)) return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Invokes a callback for each element in iteration order.\n   *\n   * @param callbackfn Function invoked per element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns `void`.\n   *\n   * @remarks\n   * Time O(n), Space O(1).\n   */\n  forEach(callbackfn: ElementCallback<E, R, void>, thisArg?: unknown): void {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        callbackfn(item, index++, this);\n      } else {\n        const fn = callbackfn as (this: unknown, v: E, i: number, self: this) => void;\n        fn.call(thisArg, item, index++, this);\n      }\n    }\n  }\n\n  /**\n   * Finds the first element that satisfies the predicate and returns it.\n   *\n   * @overload\n   * Finds the first element of type `S` (a subtype of `E`) that satisfies the predicate and returns it.\n   * @template S\n   * @param predicate Type-guard predicate: `(value, index, self) => value is S`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns The matched element typed as `S`, or `undefined` if not found.\n   *\n   * @overload\n   * @param predicate Boolean predicate: `(value, index, self) => boolean`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns The first matching element as `E`, or `undefined` if not found.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early on the first match. Space O(1).\n   */\n  find<S extends E>(predicate: ElementCallback<E, R, S>, thisArg?: unknown): S | undefined;\n  find(predicate: ElementCallback<E, R, unknown>, thisArg?: unknown): E | undefined;\n\n  // Implementation signature\n  find(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): E | undefined {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (predicate(item, index++, this)) return item;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (fn.call(thisArg, item, index++, this)) return item;\n      }\n    }\n    return;\n  }\n\n  /**\n   * Checks whether a strictly-equal element exists in the structure.\n   *\n   * @param element The element to test with `===` equality.\n   * @returns `true` if an equal element is found; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case. Space O(1).\n   */\n  has(element: E): boolean {\n    for (const ele of this) if (ele === element) return true;\n    return false;\n  }\n\n  reduce(callbackfn: ReduceElementCallback<E, R>): E;\n  reduce(callbackfn: ReduceElementCallback<E, R>, initialValue: E): E;\n  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue: U): U;\n\n  /**\n   * Reduces all elements to a single accumulated value.\n   *\n   * @overload\n   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`. The first element is used as the initial accumulator.\n   * @returns The final accumulated value typed as `E`.\n   *\n   * @overload\n   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`.\n   * @param initialValue The initial accumulator value of type `E`.\n   * @returns The final accumulated value typed as `E`.\n   *\n   * @overload\n   * @template U The accumulator type when it differs from `E`.\n   * @param callbackfn Reducer of signature `(acc: U, value, index, self) => U`.\n   * @param initialValue The initial accumulator value of type `U`.\n   * @returns The final accumulated value typed as `U`.\n   *\n   * @remarks\n   * Time O(n), Space O(1). Throws if called on an empty structure without `initialValue`.\n   */\n  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue?: U): U {\n    let index = 0;\n    const iter = this[Symbol.iterator]();\n    let acc: U;\n\n    if (arguments.length >= 2) {\n      acc = initialValue as U;\n    } else {\n      const first = iter.next();\n      if (first.done) throw new TypeError('Reduce of empty structure with no initial value');\n      acc = first.value as unknown as U;\n      index = 1;\n    }\n\n    for (const value of iter as unknown as Iterable<E>) {\n      acc = callbackfn(acc, value, index++, this);\n    }\n    return acc;\n  }\n\n  /**\n   * Materializes the elements into a new array.\n   *\n   * @returns A shallow array copy of the iteration order.\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  toArray(): E[] {\n    return [...this];\n  }\n\n  /**\n   * Returns a representation of the structure suitable for quick visualization.\n   * Defaults to an array of elements; subclasses may override to provide richer visuals.\n   *\n   * @returns A visual representation (array by default).\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  toVisual(): E[] {\n    return [...this];\n  }\n\n  /**\n   * Prints `toVisual()` to the console. Intended for quick debugging.\n   *\n   * @returns `void`.\n   * @remarks\n   * Time O(n) due to materialization, Space O(n) for the intermediate representation.\n   */\n  print(): void {\n    console.log(this.toVisual());\n  }\n\n  /**\n   * Indicates whether the structure currently contains no elements.\n   *\n   * @returns `true` if empty; otherwise `false`.\n   * @remarks\n   * Expected Time O(1), Space O(1) for most implementations.\n   */\n  abstract isEmpty(): boolean;\n\n  /**\n   * Removes all elements from the structure.\n   *\n   * @returns `void`.\n   * @remarks\n   * Expected Time O(1) or O(n) depending on the implementation; Space O(1).\n   */\n  abstract clear(): void;\n\n  /**\n   * Creates a structural copy with the same element values and configuration.\n   *\n   * @returns A clone of the current instance (same concrete type).\n   * @remarks\n   * Expected Time O(n) to copy elements; Space O(n).\n   */\n  abstract clone(): this;\n\n  /**\n   * Maps each element to a new element and returns a new iterable structure.\n   *\n   * @template EM The mapped element type.\n   * @template RM The mapped raw element type used internally by the target structure.\n   * @param callback Function with signature `(value, index, self) => mapped`.\n   * @param options Optional options for the returned structure, including its `toElementFn`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns A new `IterableElementBase<EM, RM>` containing mapped elements.\n   *\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  abstract map<EM, RM>(\n    callback: ElementCallback<E, R, EM>,\n    options?: IterableElementBaseOptions<EM, RM>,\n    thisArg?: unknown\n  ): IterableElementBase<EM, RM>;\n\n  /**\n   * Maps each element to the same element type and returns the same concrete structure type.\n   *\n   * @param callback Function with signature `(value, index, self) => mappedValue`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns A new instance of the same concrete type with mapped elements.\n   *\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  abstract mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;\n\n  /**\n   * Filters elements using the provided predicate and returns the same concrete structure type.\n   *\n   * @param predicate Function with signature `(value, index, self) => boolean`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns A new instance of the same concrete type containing only elements that pass the predicate.\n   *\n   * @remarks\n   * Time O(n), Space O(k) where `k` is the number of kept elements.\n   */\n  abstract filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this;\n\n  /**\n   * Internal iterator factory used by the default iterator.\n   *\n   * @param args Optional iterator arguments.\n   * @returns An iterator over elements.\n   *\n   * @remarks\n   * Implementations should yield in O(1) per element with O(1) extra space when possible.\n   */\n  protected abstract _getIterator(...args: unknown[]): IterableIterator<E>;\n}\n","/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\n\nimport type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '../../types';\nimport { IterableElementBase } from '../base';\n\n/**\n * Binary heap with pluggable comparator; supports fast insertion and removal of the top element.\n * @remarks Time O(1), Space O(1)\n * @template E\n * @template R\n * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.\n * 2. Heap Properties: Each node in a heap follows a specific order property, which varies depending on the type of heap:\n * Max Heap: The value of each parent node is greater than or equal to the value of its children.\n * Min Heap: The value of each parent node is less than or equal to the value of its children.\n * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.\n * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).\n * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.\n * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.\n * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.\n * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.\n * @example\n * // basic Heap creation and add operation\n *  // Create a min heap (default)\n *     const minHeap = new Heap([5, 3, 7, 1, 9, 2]);\n *\n *     // Verify size\n *     console.log(minHeap.size); // 6;\n *\n *     // Add new element\n *     minHeap.add(4);\n *     console.log(minHeap.size); // 7;\n *\n *     // Min heap property: smallest element at root\n *     const min = minHeap.peek();\n *     console.log(min); // 1;\n * @example\n * // Heap with custom comparator (MaxHeap behavior)\n *  interface Task {\n *       id: number;\n *       priority: number;\n *       name: string;\n *     }\n *\n *     // Custom comparator for max heap behavior (higher priority first)\n *     const tasks: Task[] = [\n *       { id: 1, priority: 5, name: 'Email' },\n *       { id: 2, priority: 3, name: 'Chat' },\n *       { id: 3, priority: 8, name: 'Alert' }\n *     ];\n *\n *     const maxHeap = new Heap(tasks, {\n *       comparator: (a: Task, b: Task) => b.priority - a.priority\n *     });\n *\n *     console.log(maxHeap.size); // 3;\n *\n *     // Peek returns highest priority task\n *     const topTask = maxHeap.peek();\n *     console.log(topTask?.priority); // 8;\n *     console.log(topTask?.name); // 'Alert';\n * @example\n * // Heap for event processing with priority\n *  interface Event {\n *       id: number;\n *       type: 'critical' | 'warning' | 'info';\n *       timestamp: number;\n *       message: string;\n *     }\n *\n *     // Custom priority: critical > warning > info\n *     const priorityMap = { critical: 3, warning: 2, info: 1 };\n *\n *     const eventHeap = new Heap<Event>([], {\n *       comparator: (a: Event, b: Event) => {\n *         const priorityA = priorityMap[a.type];\n *         const priorityB = priorityMap[b.type];\n *         return priorityB - priorityA; // Higher priority first\n *       }\n *     });\n *\n *     // Add events in random order\n *     eventHeap.add({ id: 1, type: 'info', timestamp: 100, message: 'User logged in' });\n *     eventHeap.add({ id: 2, type: 'critical', timestamp: 101, message: 'Server down' });\n *     eventHeap.add({ id: 3, type: 'warning', timestamp: 102, message: 'High memory' });\n *     eventHeap.add({ id: 4, type: 'info', timestamp: 103, message: 'Cache cleared' });\n *     eventHeap.add({ id: 5, type: 'critical', timestamp: 104, message: 'Database error' });\n *\n *     console.log(eventHeap.size); // 5;\n *\n *     // Process events by priority (critical first)\n *     const processedOrder: Event[] = [];\n *     while (eventHeap.size > 0) {\n *       const event = eventHeap.poll();\n *       if (event) {\n *         processedOrder.push(event);\n *       }\n *     }\n *\n *     // Verify critical events came first\n *     console.log(processedOrder[0].type); // 'critical';\n *     console.log(processedOrder[1].type); // 'critical';\n *     console.log(processedOrder[2].type); // 'warning';\n *     console.log(processedOrder[3].type); // 'info';\n *     console.log(processedOrder[4].type); // 'info';\n *\n *     // Verify O(log n) operations\n *     const newHeap = new Heap<number>([5, 3, 7, 1]);\n *\n *     // Add - O(log n)\n *     newHeap.add(2);\n *     console.log(newHeap.size); // 5;\n *\n *     // Poll - O(log n)\n *     const removed = newHeap.poll();\n *     console.log(removed); // 1;\n *\n *     // Peek - O(1)\n *     const top = newHeap.peek();\n *     console.log(top); // 2;\n * @example\n * // Use Heap to solve top k problems\n *  function topKElements(arr: number[], k: number): number[] {\n *       const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap\n *       arr.forEach(num => {\n *         heap.add(num);\n *         if (heap.size > k) heap.poll(); // Keep the heap size at K\n *       });\n *       return heap.toArray();\n *     }\n *\n *     const numbers = [10, 30, 20, 5, 15, 25];\n *     console.log(topKElements(numbers, 3)); // [15, 10, 5];\n * @example\n * // Use Heap to dynamically maintain the median\n *  class MedianFinder {\n *       private low: MaxHeap<number>; // Max heap, stores the smaller half\n *       private high: MinHeap<number>; // Min heap, stores the larger half\n *\n *       constructor() {\n *         this.low = new MaxHeap<number>([]);\n *         this.high = new MinHeap<number>([]);\n *       }\n *\n *       addNum(num: number): void {\n *         if (this.low.isEmpty() || num <= this.low.peek()!) this.low.add(num);\n *         else this.high.add(num);\n *\n *         // Balance heaps\n *         if (this.low.size > this.high.size + 1) this.high.add(this.low.poll()!);\n *         else if (this.high.size > this.low.size) this.low.add(this.high.poll()!);\n *       }\n *\n *       findMedian(): number {\n *         if (this.low.size === this.high.size) return (this.low.peek()! + this.high.peek()!) / 2;\n *         return this.low.peek()!;\n *       }\n *     }\n *\n *     const medianFinder = new MedianFinder();\n *     medianFinder.addNum(10);\n *     console.log(medianFinder.findMedian()); // 10;\n *     medianFinder.addNum(20);\n *     console.log(medianFinder.findMedian()); // 15;\n *     medianFinder.addNum(30);\n *     console.log(medianFinder.findMedian()); // 20;\n *     medianFinder.addNum(40);\n *     console.log(medianFinder.findMedian()); // 25;\n *     medianFinder.addNum(50);\n *     console.log(medianFinder.findMedian()); // 30;\n * @example\n * // Use Heap for load balancing\n *  function loadBalance(requests: number[], servers: number): number[] {\n *       const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap\n *       const serverLoads = new Array(servers).fill(0);\n *\n *       for (let i = 0; i < servers; i++) {\n *         serverHeap.add({ id: i, load: 0 });\n *       }\n *\n *       requests.forEach(req => {\n *         const server = serverHeap.poll()!;\n *         serverLoads[server.id] += req;\n *         server.load += req;\n *         serverHeap.add(server); // The server after updating the load is re-entered into the heap\n *       });\n *\n *       return serverLoads;\n *     }\n *\n *     const requests = [5, 2, 8, 3, 7];\n *     console.log(loadBalance(requests, 3)); // [12, 8, 5];\n * @example\n * // Use Heap to schedule tasks\n *  type Task = [string, number];\n *\n *     function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {\n *       const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap\n *       const allocation = new Map<number, Task[]>();\n *\n *       // Initialize the load on each machine\n *       for (let i = 0; i < machines; i++) {\n *         machineHeap.add({ id: i, load: 0 });\n *         allocation.set(i, []);\n *       }\n *\n *       // Assign tasks\n *       tasks.forEach(([task, load]) => {\n *         const machine = machineHeap.poll()!;\n *         allocation.get(machine.id)!.push([task, load]);\n *         machine.load += load;\n *         machineHeap.add(machine); // The machine after updating the load is re-entered into the heap\n *       });\n *\n *       return allocation;\n *     }\n *\n *     const tasks: Task[] = [\n *       ['Task1', 3],\n *       ['Task2', 1],\n *       ['Task3', 2],\n *       ['Task4', 5],\n *       ['Task5', 4]\n *     ];\n *     const expectedMap = new Map<number, Task[]>();\n *     expectedMap.set(0, [\n *       ['Task1', 3],\n *       ['Task4', 5]\n *     ]);\n *     expectedMap.set(1, [\n *       ['Task2', 1],\n *       ['Task3', 2],\n *       ['Task5', 4]\n *     ]);\n *     console.log(scheduleTasks(tasks, 2)); // expectedMap;\n */\nexport class Heap<E = any, R = any> extends IterableElementBase<E, R> {\n  protected _equals: (a: E, b: E) => boolean = Object.is;\n\n  /**\n   * Create a Heap and optionally bulk-insert elements.\n   * @remarks Time O(N), Space O(N)\n   * @param [elements] - Iterable of elements (or raw values if toElementFn is set).\n   * @param [options] - Options such as comparator and toElementFn.\n   * @returns New Heap instance.\n   */\n\n  constructor(elements: Iterable<E | R> = [], options?: HeapOptions<E, R>) {\n    super(options);\n\n    if (options) {\n      const { comparator } = options;\n      if (comparator) this._comparator = comparator;\n    }\n\n    this.addMany(elements as Iterable<E | R>);\n  }\n\n  protected _elements: E[] = [];\n\n  /**\n   * Get the backing array of the heap.\n   * @remarks Time O(1), Space O(1)\n   * @returns Internal elements array.\n   */\n\n  get elements(): E[] {\n    return this._elements;\n  }\n\n  /**\n   * Get the number of elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns Heap size.\n   */\n\n  get size(): number {\n    return this.elements.length;\n  }\n\n  /**\n   * Get the last leaf element.\n   * @remarks Time O(1), Space O(1)\n   * @returns Last element or undefined.\n   */\n\n  get leaf(): E | undefined {\n    return this.elements[this.size - 1] ?? undefined;\n  }\n\n  /**\n   * Create a heap of the same class from an iterable.\n   * @remarks Time O(N), Space O(N)\n   * @template T\n   * @template R\n   * @template S\n   * @param [elements] - Iterable of elements or raw records.\n   * @param [options] - Heap options including comparator.\n   * @returns A new heap instance of this class.\n   */\n\n  static from<T, R = any, S extends Heap<T, R> = Heap<T, R>>(\n    this: new (elements?: Iterable<T | R>, options?: HeapOptions<T, R>) => S,\n    elements?: Iterable<T | R>,\n    options?: HeapOptions<T, R>\n  ): S {\n    return new this(elements, options);\n  }\n\n  /**\n   * Build a Heap from an iterable in linear time given a comparator.\n   * @remarks Time O(N), Space O(N)\n   * @template EE\n   * @template RR\n   * @param elements - Iterable of elements.\n   * @param options - Heap options including comparator.\n   * @returns A new Heap built from elements.\n   */\n\n  static heapify<EE = any, RR = any>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {\n    return new Heap<EE, RR>(elements, options);\n  }\n\n  /**\n   * Insert an element.\n   * @remarks Time O(1) amortized, Space O(1)\n   * @param element - Element to insert.\n   * @returns True.\n   */\n\n  add(element: E): boolean {\n    this._elements.push(element);\n    return this._bubbleUp(this.elements.length - 1);\n  }\n\n  /**\n   * Insert many elements from an iterable.\n   * @remarks Time O(N log N), Space O(1)\n   * @param elements - Iterable of elements or raw values.\n   * @returns Array of per-element success flags.\n   */\n\n  addMany(elements: Iterable<E | R>): boolean[] {\n    const flags: boolean[] = [];\n    for (const el of elements) {\n      if (this.toElementFn) {\n        const ok = this.add(this.toElementFn(el as R));\n        flags.push(ok);\n      } else {\n        const ok = this.add(el as E);\n        flags.push(ok);\n      }\n    }\n    return flags;\n  }\n\n  /**\n   * Remove and return the top element.\n   * @remarks Time O(log N), Space O(1)\n   * @returns Top element or undefined.\n   */\n\n  poll(): E | undefined {\n    if (this.elements.length === 0) return;\n    const value = this.elements[0];\n    const last = this.elements.pop()!;\n    if (this.elements.length) {\n      this.elements[0] = last;\n      this._sinkDown(0, this.elements.length >> 1);\n    }\n    return value;\n  }\n\n  /**\n   * Get the current top element without removing it.\n   * @remarks Time O(1), Space O(1)\n   * @returns Top element or undefined.\n   */\n\n  peek(): E | undefined {\n    return this.elements[0];\n  }\n\n  /**\n   * Check whether the heap is empty.\n   * @remarks Time O(1), Space O(1)\n   * @returns True if size is 0.\n   */\n\n  isEmpty(): boolean {\n    return this.size === 0;\n  }\n\n  /**\n   * Remove all elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns void\n   */\n\n  clear(): void {\n    this._elements = [];\n  }\n\n  /**\n   * Replace the backing array and rebuild the heap.\n   * @remarks Time O(N), Space O(N)\n   * @param elements - Iterable used to refill the heap.\n   * @returns Array of per-node results from fixing steps.\n   */\n\n  refill(elements: Iterable<E>): boolean[] {\n    this._elements = Array.from(elements);\n    return this.fix();\n  }\n\n  /**\n   * Check if an equal element exists in the heap.\n   * @remarks Time O(N), Space O(1)\n   * @param element - Element to search for.\n   * @returns True if found.\n   */\n\n  override has(element: E): boolean {\n    for (const el of this.elements) if (this._equals(el, element)) return true;\n    return false;\n  }\n\n  /**\n   * Delete one occurrence of an element.\n   * @remarks Time O(N), Space O(1)\n   * @param element - Element to delete.\n   * @returns True if an element was removed.\n   */\n\n  delete(element: E): boolean {\n    let index = -1;\n    for (let i = 0; i < this.elements.length; i++) {\n      if (this._equals(this.elements[i], element)) {\n        index = i;\n        break;\n      }\n    }\n    if (index < 0) return false;\n    if (index === 0) {\n      this.poll();\n    } else if (index === this.elements.length - 1) {\n      this.elements.pop();\n    } else {\n      this.elements.splice(index, 1, this.elements.pop()!);\n      this._bubbleUp(index);\n      this._sinkDown(index, this.elements.length >> 1);\n    }\n    return true;\n  }\n\n  /**\n   * Delete the first element that matches a predicate.\n   * @remarks Time O(N), Space O(1)\n   * @param predicate - Function (element, index, heap) → boolean.\n   * @returns True if an element was removed.\n   */\n\n  deleteBy(predicate: (element: E, index: number, heap: this) => boolean): boolean {\n    let idx = -1;\n    for (let i = 0; i < this.elements.length; i++) {\n      if (predicate(this.elements[i], i, this)) {\n        idx = i;\n        break;\n      }\n    }\n    if (idx < 0) return false;\n    if (idx === 0) {\n      this.poll();\n    } else if (idx === this.elements.length - 1) {\n      this.elements.pop();\n    } else {\n      this.elements.splice(idx, 1, this.elements.pop()!);\n      this._bubbleUp(idx);\n      this._sinkDown(idx, this.elements.length >> 1);\n    }\n    return true;\n  }\n\n  /**\n   * Set the equality comparator used by has/delete operations.\n   * @remarks Time O(1), Space O(1)\n   * @param equals - Equality predicate (a, b) → boolean.\n   * @returns This heap.\n   */\n\n  setEquality(equals: (a: E, b: E) => boolean): this {\n    this._equals = equals;\n    return this;\n  }\n\n  /**\n   * Traverse the binary heap as a complete binary tree and collect elements.\n   * @remarks Time O(N), Space O(H)\n   * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.\n   * @returns Array of visited elements.\n   */\n\n  dfs(order: DFSOrderPattern = 'PRE'): E[] {\n    const result: E[] = [];\n    const _dfs = (index: number) => {\n      const left = 2 * index + 1,\n        right = left + 1;\n      if (index < this.size) {\n        if (order === 'IN') {\n          _dfs(left);\n          result.push(this.elements[index]);\n          _dfs(right);\n        } else if (order === 'PRE') {\n          result.push(this.elements[index]);\n          _dfs(left);\n          _dfs(right);\n        } else if (order === 'POST') {\n          _dfs(left);\n          _dfs(right);\n          result.push(this.elements[index]);\n        }\n      }\n    };\n    _dfs(0);\n    return result;\n  }\n\n  /**\n   * Restore heap order bottom-up (heapify in-place).\n   * @remarks Time O(N), Space O(1)\n   * @returns Array of per-node results from fixing steps.\n   */\n\n  fix(): boolean[] {\n    const results: boolean[] = [];\n    for (let i = Math.floor(this.size / 2) - 1; i >= 0; i--) {\n      results.push(this._sinkDown(i, this.elements.length >> 1));\n    }\n    return results;\n  }\n\n  /**\n   * Return all elements in ascending order by repeatedly polling.\n   * @remarks Time O(N log N), Space O(N)\n   * @returns Sorted array of elements.\n   */\n\n  sort(): E[] {\n    const visited: E[] = [];\n    const cloned = this._createInstance();\n    for (const x of this.elements) cloned.add(x);\n    while (!cloned.isEmpty()) {\n      const top = cloned.poll();\n      if (top !== undefined) visited.push(top);\n    }\n    return visited;\n  }\n\n  /**\n   * Deep clone this heap.\n   * @remarks Time O(N), Space O(N)\n   * @returns A new heap with the same elements.\n   */\n\n  clone(): this {\n    const next = this._createInstance();\n    for (const x of this.elements) next.add(x);\n    return next;\n  }\n\n  /**\n   * Filter elements into a new heap of the same class.\n   * @remarks Time O(N log N), Space O(N)\n   * @param callback - Predicate (element, index, heap) → boolean to keep element.\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new heap with the kept elements.\n   */\n\n  filter(callback: ElementCallback<E, R, boolean>, thisArg?: unknown): this {\n    const out = this._createInstance();\n    let i = 0;\n    for (const x of this) {\n      if (thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this)) {\n        out.add(x);\n      } else {\n        i++;\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Map elements into a new heap of possibly different element type.\n   * @remarks Time O(N log N), Space O(N)\n   * @template EM\n   * @template RM\n   * @param callback - Mapping function (element, index, heap) → newElement.\n   * @param options - Options for the output heap, including comparator for EM.\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new heap with mapped elements.\n   */\n\n  map<EM, RM>(\n    callback: ElementCallback<E, R, EM>,\n    options: HeapOptions<EM, RM> & { comparator: Comparator<EM> },\n    thisArg?: unknown\n  ): Heap<EM, RM> {\n    const { comparator, toElementFn, ...rest } = options ?? {};\n    if (!comparator) throw new TypeError('Heap.map requires options.comparator for EM');\n    const out = this._createLike<EM, RM>([], { ...rest, comparator, toElementFn });\n    let i = 0;\n    for (const x of this) {\n      const v = thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);\n      out.add(v);\n    }\n    return out;\n  }\n\n  /**\n   * Map elements into a new heap of the same element type.\n   * @remarks Time O(N log N), Space O(N)\n   * @param callback - Mapping function (element, index, heap) → element.\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new heap with mapped elements.\n   */\n\n  mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this {\n    const out = this._createInstance();\n    let i = 0;\n    for (const x of this) {\n      const v = thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);\n      out.add(v);\n    }\n    return out;\n  }\n\n  protected _DEFAULT_COMPARATOR = (a: E, b: E): number => {\n    if (typeof a === 'object' || typeof b === 'object') {\n      throw TypeError('When comparing object types, define a custom comparator in options.');\n    }\n    if ((a as unknown as number) > (b as unknown as number)) return 1;\n    if ((a as unknown as number) < (b as unknown as number)) return -1;\n    return 0;\n  };\n\n  protected _comparator: Comparator<E> = this._DEFAULT_COMPARATOR; /**\n   * Get the comparator used to order elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns Comparator function.\n   */\n  /**\n   * Get the comparator used to order elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns Comparator function.\n   */\n\n  get comparator() {\n    return this._comparator;\n  }\n\n  protected *_getIterator(): IterableIterator<E> {\n    for (const element of this.elements) yield element;\n  }\n\n  protected _bubbleUp(index: number): boolean {\n    const element = this.elements[index];\n    while (index > 0) {\n      const parent = (index - 1) >> 1;\n      const parentItem = this.elements[parent];\n      if (this.comparator(parentItem, element) <= 0) break;\n      this.elements[index] = parentItem;\n      index = parent;\n    }\n    this.elements[index] = element;\n    return true;\n  }\n\n  protected _sinkDown(index: number, halfLength: number): boolean {\n    const element = this.elements[index];\n    while (index < halfLength) {\n      let left = (index << 1) | 1;\n      const right = left + 1;\n      let minItem = this.elements[left];\n      if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {\n        left = right;\n        minItem = this.elements[right];\n      }\n      if (this.comparator(minItem, element) >= 0) break;\n      this.elements[index] = minItem;\n      index = left;\n    }\n    this.elements[index] = element;\n    return true;\n  }\n\n  /**\n   * (Protected) Create an empty instance of the same concrete class.\n   * @remarks Time O(1), Space O(1)\n   * @param [options] - Options to override comparator or toElementFn.\n   * @returns A like-kind empty heap instance.\n   */\n\n  protected _createInstance(options?: HeapOptions<E, R>): this {\n    const Ctor: any = this.constructor;\n    const next: any = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...(options ?? {}) });\n    return next as this;\n  }\n\n  /**\n   * (Protected) Create a like-kind instance seeded by elements.\n   * @remarks Time O(N log N), Space O(N)\n   * @template EM\n   * @template RM\n   * @param [elements] - Iterable of elements or raw values to seed.\n   * @param [options] - Options forwarded to the constructor.\n   * @returns A like-kind heap instance.\n   */\n\n  protected _createLike<EM, RM>(\n    elements: Iterable<EM> | Iterable<RM> = [],\n    options?: HeapOptions<EM, RM>\n  ): Heap<EM, RM> {\n    const Ctor: any = this.constructor;\n    return new Ctor(elements, options) as Heap<EM, RM>;\n  }\n\n  /**\n   * (Protected) Spawn an empty like-kind heap instance.\n   * @remarks Time O(1), Space O(1)\n   * @template EM\n   * @template RM\n   * @param [options] - Options forwarded to the constructor.\n   * @returns An empty like-kind heap instance.\n   */\n\n  protected _spawnLike<EM, RM>(options?: HeapOptions<EM, RM>): Heap<EM, RM> {\n    return this._createLike<EM, RM>([], options);\n  }\n}\n\n/**\n * Node container used by FibonacciHeap.\n * @remarks Time O(1), Space O(1)\n * @template E\n */\nexport class FibonacciHeapNode<E> {\n  element: E;\n  degree: number;\n  left?: FibonacciHeapNode<E>;\n  right?: FibonacciHeapNode<E>;\n  child?: FibonacciHeapNode<E>;\n  parent?: FibonacciHeapNode<E>;\n  marked: boolean;\n\n  constructor(element: E, degree = 0) {\n    this.element = element;\n    this.degree = degree;\n    this.marked = false;\n  }\n}\n\n/**\n * Fibonacci heap (min-heap) optimized for fast merges and amortized operations.\n * @remarks Time O(1), Space O(1)\n * @template E\n * @example examples will be generated by unit test\n */\nexport class FibonacciHeap<E> {\n  /**\n   * Create a FibonacciHeap.\n   * @remarks Time O(1), Space O(1)\n   * @param [comparator] - Comparator to order elements (min-heap by default).\n   * @returns New FibonacciHeap instance.\n   */\n\n  constructor(comparator?: Comparator<E>) {\n    this.clear();\n    this._comparator = comparator || this._defaultComparator;\n    if (typeof this.comparator !== 'function') throw new Error('FibonacciHeap: comparator must be a function.');\n  }\n\n  protected _root?: FibonacciHeapNode<E>;\n\n  /**\n   * Get the circular root list head.\n   * @remarks Time O(1), Space O(1)\n   * @returns Root node or undefined.\n   */\n\n  get root(): FibonacciHeapNode<E> | undefined {\n    return this._root;\n  }\n\n  protected _size = 0;\n  get size(): number {\n    return this._size;\n  }\n\n  protected _min?: FibonacciHeapNode<E>;\n\n  /**\n   * Get the current minimum node.\n   * @remarks Time O(1), Space O(1)\n   * @returns Min node or undefined.\n   */\n\n  get min(): FibonacciHeapNode<E> | undefined {\n    return this._min;\n  }\n\n  protected _comparator: Comparator<E>;\n  get comparator(): Comparator<E> {\n    return this._comparator;\n  }\n\n  clear(): void {\n    this._root = undefined;\n    this._min = undefined;\n    this._size = 0;\n  }\n\n  add(element: E): boolean {\n    this.push(element);\n    return true;\n  }\n\n  /**\n   * Push an element into the root list.\n   * @remarks Time O(1) amortized, Space O(1)\n   * @param element - Element to insert.\n   * @returns This heap.\n   */\n\n  push(element: E): this {\n    const node = this.createNode(element);\n    node.left = node;\n    node.right = node;\n    this.mergeWithRoot(node);\n    if (!this.min || this.comparator(node.element, this.min.element) <= 0) this._min = node;\n    this._size++;\n    return this;\n  }\n\n  peek(): E | undefined {\n    return this.min ? this.min.element : undefined;\n  }\n\n  /**\n   * Collect nodes from a circular doubly linked list starting at head.\n   * @remarks Time O(K), Space O(K)\n   * @param [head] - Start node of the circular list.\n   * @returns Array of nodes from the list.\n   */\n\n  consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[] {\n    const elements: FibonacciHeapNode<E>[] = [];\n    if (!head) return elements;\n    let node: FibonacciHeapNode<E> | undefined = head;\n    let started = false;\n    while (true) {\n      if (node === head && started) break;\n      else if (node === head) started = true;\n      elements.push(node!);\n      node = node!.right;\n    }\n    return elements;\n  }\n\n  /**\n   * Insert a node into a parent's child list (circular).\n   * @remarks Time O(1), Space O(1)\n   * @param parent - Parent node.\n   * @param node - Child node to insert.\n   * @returns void\n   */\n\n  mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void {\n    if (!parent.child) parent.child = node;\n    else {\n      node.right = parent.child.right;\n      node.left = parent.child;\n      parent.child.right!.left = node;\n      parent.child.right = node;\n    }\n  }\n\n  poll(): E | undefined {\n    return this.pop();\n  }\n\n  /**\n   * Remove and return the minimum element, consolidating the root list.\n   * @remarks Time O(log N) amortized, Space O(1)\n   * @returns Minimum element or undefined.\n   */\n\n  pop(): E | undefined {\n    if (this._size === 0) return undefined;\n    const z = this.min!;\n    if (z.child) {\n      const elements = this.consumeLinkedList(z.child);\n      for (const node of elements) {\n        this.mergeWithRoot(node);\n        node.parent = undefined;\n      }\n    }\n    this.removeFromRoot(z);\n    if (z === z.right) {\n      this._min = undefined;\n      this._root = undefined;\n    } else {\n      this._min = z.right;\n      this._consolidate();\n    }\n    this._size--;\n    return z.element;\n  }\n\n  /**\n   * Meld another heap into this heap.\n   * @remarks Time O(1), Space O(1)\n   * @param heapToMerge - Another FibonacciHeap to meld into this one.\n   * @returns void\n   */\n\n  merge(heapToMerge: FibonacciHeap<E>): void {\n    if (heapToMerge.size === 0) return;\n    if (this.root && heapToMerge.root) {\n      const thisRoot = this.root,\n        otherRoot = heapToMerge.root;\n      const thisRootRight = thisRoot.right!,\n        otherRootLeft = otherRoot.left!;\n      thisRoot.right = otherRoot;\n      otherRoot.left = thisRoot;\n      thisRootRight.left = otherRootLeft;\n      otherRootLeft.right = thisRootRight;\n    } else if (!this.root && heapToMerge.root) {\n      this._root = heapToMerge.root;\n    }\n    if (!this.min || (heapToMerge.min && this.comparator(heapToMerge.min.element, this.min.element) < 0)) {\n      this._min = heapToMerge.min;\n    }\n    this._size += heapToMerge.size;\n    heapToMerge.clear();\n  }\n\n  createNode(element: E): FibonacciHeapNode<E> {\n    return new FibonacciHeapNode<E>(element);\n  }\n\n  isEmpty(): boolean {\n    return this._size === 0;\n  }\n\n  protected _defaultComparator(a: E, b: E): number {\n    if (a < b) return -1;\n    if (a > b) return 1;\n    return 0;\n  }\n\n  protected mergeWithRoot(node: FibonacciHeapNode<E>): void {\n    if (!this.root) this._root = node;\n    else {\n      node.right = this.root.right;\n      node.left = this.root;\n      this.root.right!.left = node;\n      this.root.right = node;\n    }\n  }\n\n  protected removeFromRoot(node: FibonacciHeapNode<E>): void {\n    if (this.root === node) this._root = node.right;\n    if (node.left) node.left.right = node.right;\n    if (node.right) node.right.left = node.left;\n  }\n\n  protected _link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {\n    this.removeFromRoot(y);\n    y.left = y;\n    y.right = y;\n    this.mergeWithChild(x, y);\n    x.degree++;\n    y.parent = x;\n  }\n\n  protected _consolidate(): void {\n    const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this._size);\n    const elements = this.consumeLinkedList(this.root);\n    let x: FibonacciHeapNode<E> | undefined,\n      y: FibonacciHeapNode<E> | undefined,\n      d: number,\n      t: FibonacciHeapNode<E> | undefined;\n\n    for (const node of elements) {\n      x = node;\n      d = x.degree;\n      while (A[d]) {\n        y = A[d] as FibonacciHeapNode<E>;\n        if (this.comparator(x.element, y.element) > 0) {\n          t = x;\n          x = y;\n          y = t;\n        }\n        this._link(y, x);\n        A[d] = undefined;\n        d++;\n      }\n      A[d] = x;\n    }\n\n    for (let i = 0; i < A.length; i++) {\n      if (A[i] && (!this.min || this.comparator(A[i]!.element, this.min.element) <= 0)) this._min = A[i]!;\n    }\n  }\n}\n","/**\n * data-structure-typed\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\nimport type { HeapOptions } from '../../types';\nimport { Heap } from './heap';\n\n/**\n * @template E\n * @template R\n * Max-oriented binary heap.\n * Notes and typical use-cases are documented in {@link Heap}.\n *\n * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.\n * 2. Heap Properties: The value of each parent node is greater than or equal to the value of its children.\n * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.\n * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).\n * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.\n * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.\n * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.\n * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum-spanning tree algorithm, which use heaps to improve performance.\n * @example\n */\nexport class MaxHeap<E = any, R = any> extends Heap<E, R> {\n  /**\n   * Create a max-heap. For objects, supply a custom comparator.\n   * @param elements Optional initial elements.\n   * @param options Optional configuration.\n   */\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: HeapOptions<E, R>) {\n    super(elements, {\n      comparator: (a: E, b: E): number => {\n        if (typeof a === 'object' || typeof b === 'object') {\n          throw TypeError(\n            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`\n          );\n        }\n        if (a < b) return 1;\n        if (a > b) return -1;\n        return 0;\n      },\n      ...options\n    });\n  }\n}\n","/**\n * @remarks Time O(n log n), Space O(n).\n * data-structure-typed\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\nimport type { HeapOptions } from '../../types';\nimport { Heap } from './heap';\n\n/**\n * @template E\n * @template R\n * Min-oriented binary heap.\n * Notes and typical use-cases are documented in {@link Heap}.\n *\n * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.\n * 2. MinHeap Properties:  The value of each parent node is less than or equal to the value of its children.\n * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.\n * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).\n * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.\n * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.\n * 7. Efficient Sorting Algorithms: For example, heap sort. MinHeap sort uses the properties of a heap to sort elements.\n * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.\n * @example\n */\nexport class MinHeap<E = any, R = any> extends Heap<E, R> {\n  /**\n   * Create a min-heap.\n   * @param elements Optional initial elements.\n   * @param options Optional configuration.\n   */\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: HeapOptions<E, R>) {\n    super(elements, options);\n  }\n}\n","/**\n * data-structure-typed\n *\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\n\nimport type { PriorityQueueOptions } from '../../types';\nimport { Heap } from '../heap';\n\n/**\n * @example\n */\nexport class PriorityQueue<E = any, R = any> extends Heap<E, R> {\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: PriorityQueueOptions<E, R>) {\n    super(elements, options);\n  }\n}\n","/**\n * data-structure-typed\n *\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\nimport type { PriorityQueueOptions } from '../../types';\nimport { PriorityQueue } from './priority-queue';\n\n/**\n * Min-oriented priority queue (min-heap) built on {@link PriorityQueue}.\n * The queue removes the smallest element first under the provided comparator.\n * Provide a custom comparator if you store non-primitive objects.\n * @template E Element type stored in the queue.\n * @template R Extra record/metadata associated with each element.\n * @example\n */\nexport class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {\n  /**\n   * Creates a min-priority queue.\n   * @param elements Optional initial elements to insert.\n   * @param options Optional configuration (e.g., `comparator`, `toElementFn`).\n   * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).\n   */\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: PriorityQueueOptions<E, R>) {\n    super(elements, options);\n  }\n}\n","/**\n * data-structure-typed\n *\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\nimport type { PriorityQueueOptions } from '../../types';\nimport { PriorityQueue } from './priority-queue';\n\n/**\n * Max-oriented priority queue (max-heap) built on {@link PriorityQueue}.\n * The default comparator orders primitive values in descending order. If you store objects,\n * you must provide a custom comparator via {@link PriorityQueueOptions}.\n * @template E Element type stored in the queue.\n * @template R Extra record/metadata associated with each element.\n * @example\n */\nexport class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {\n  /**\n   * Creates a max-priority queue.\n   * @param elements Optional initial elements to insert.\n   * @param options Optional configuration (e.g., `comparator`, `toElementFn`).\n   * @throws {TypeError} Thrown when using the default comparator with object elements (provide a custom comparator).\n   * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).\n   */\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: PriorityQueueOptions<E, R>) {\n    super(elements, {\n      comparator: (a: E, b: E): number => {\n        if (typeof a === 'object' || typeof b === 'object') {\n          throw TypeError(\n            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`\n          );\n        }\n        if (a < b) return 1;\n        if (a > b) return -1;\n        return 0;\n      },\n      ...options\n    });\n  }\n}\n","export enum DFSOperation {\n  VISIT = 0,\n  PROCESS = 1\n}\n\nexport class Range<K> {\n  constructor(\n    public low: K,\n    public high: K,\n    public includeLow: boolean = true,\n    public includeHigh: boolean = true\n  ) {\n    // if (!(isComparable(low) && isComparable(high))) throw new RangeError('low or high is not comparable');\n    // if (low > high) throw new RangeError('low must be less than or equal to high');\n  }\n\n  // Determine whether a key is within the range\n  isInRange(key: K, comparator: (a: K, b: K) => number): boolean {\n    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;\n    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;\n    return lowCheck && highCheck;\n  }\n}\n"],"mappings":"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","names":["src_exports","__export","DFSOperation","FibonacciHeap","FibonacciHeapNode","Heap","MaxHeap","MaxPriorityQueue","MinHeap","MinPriorityQueue","PriorityQueue","Range","IterableElementBase","options","__publicField","toElementFn","args","item","predicate","thisArg","index","callbackfn","element","ele","initialValue","iter","acc","first","value","Heap","_Heap","IterableElementBase","elements","options","__publicField","a","b","comparator","_a","element","flags","el","ok","value","last","index","i","predicate","idx","equals","order","result","_dfs","left","right","results","visited","cloned","x","top","next","callback","thisArg","out","toElementFn","rest","v","parent","parentItem","halfLength","minItem","Ctor","FibonacciHeapNode","degree","FibonacciHeap","node","head","started","z","heapToMerge","thisRoot","otherRoot","thisRootRight","otherRootLeft","y","A","d","t","MaxHeap","Heap","elements","options","a","b","MinHeap","Heap","elements","options","PriorityQueue","Heap","elements","options","MinPriorityQueue","PriorityQueue","elements","options","MaxPriorityQueue","PriorityQueue","elements","options","a","b","DFSOperation","Range","low","high","includeLow","includeHigh","key","comparator","lowCheck","highCheck"]}
+{"version":3,"sources":["../../src/index.ts","../../src/data-structures/base/iterable-element-base.ts","../../src/data-structures/heap/heap.ts","../../src/data-structures/heap/max-heap.ts","../../src/data-structures/heap/min-heap.ts","../../src/data-structures/priority-queue/priority-queue.ts","../../src/data-structures/priority-queue/min-priority-queue.ts","../../src/data-structures/priority-queue/max-priority-queue.ts","../../src/common/index.ts"],"sourcesContent":["/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\nexport * from './data-structures/priority-queue';\nexport * from './data-structures/heap';\nexport * from './types/data-structures/priority-queue';\nexport * from './types/data-structures/heap';\nexport * from './types/common';\nexport * from './types/utils';\nexport * from './common';","import type { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';\n\n/**\n * Base class that makes a data structure iterable and provides common\n * element-wise utilities (e.g., map/filter/reduce/find).\n *\n * @template E The public element type yielded by the structure.\n * @template R The underlying \"raw\" element type used internally or by converters.\n *\n * @remarks\n * This class implements the JavaScript iteration protocol (via `Symbol.iterator`)\n * and offers array-like helpers with predictable time/space complexity.\n */\nexport abstract class IterableElementBase<E, R> implements Iterable<E> {\n  /**\n   * Create a new iterable base.\n   *\n   * @param options Optional behavior overrides. When provided, a `toElementFn`\n   * is used to convert a raw element (`R`) into a public element (`E`).\n   *\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  protected constructor(options?: IterableElementBaseOptions<E, R>) {\n    if (options) {\n      const { toElementFn } = options;\n      if (typeof toElementFn === 'function') this._toElementFn = toElementFn;\n      else if (toElementFn) throw new TypeError('toElementFn must be a function type');\n    }\n  }\n\n  /**\n   * The converter used to transform a raw element (`R`) into a public element (`E`).\n   *\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  protected readonly _toElementFn?: (rawElement: R) => E;\n\n  /**\n   * Exposes the current `toElementFn`, if configured.\n   *\n   * @returns The converter function or `undefined` when not set.\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  get toElementFn(): ((rawElement: R) => E) | undefined {\n    return this._toElementFn;\n  }\n\n  /**\n   * Returns an iterator over the structure's elements.\n   *\n   * @param args Optional iterator arguments forwarded to the internal iterator.\n   * @returns An `IterableIterator<E>` that yields the elements in traversal order.\n   *\n   * @remarks\n   * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.\n   */\n  *[Symbol.iterator](...args: unknown[]): IterableIterator<E> {\n    yield* this._getIterator(...args);\n  }\n\n  /**\n   * Returns an iterator over the values (alias of the default iterator).\n   *\n   * @returns An `IterableIterator<E>` over all elements.\n   * @remarks\n   * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).\n   */\n  *values(): IterableIterator<E> {\n    for (const item of this) yield item;\n  }\n\n  /**\n   * Tests whether all elements satisfy the predicate.\n   *\n   * @template TReturn\n   * @param predicate Function invoked for each element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns `true` if every element passes; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).\n   */\n  every(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (!predicate(item, index++, this)) return false;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (!fn.call(thisArg, item, index++, this)) return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Tests whether at least one element satisfies the predicate.\n   *\n   * @param predicate Function invoked for each element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns `true` if any element passes; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early on first success. Space O(1).\n   */\n  some(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (predicate(item, index++, this)) return true;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (fn.call(thisArg, item, index++, this)) return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Invokes a callback for each element in iteration order.\n   *\n   * @param callbackfn Function invoked per element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns `void`.\n   *\n   * @remarks\n   * Time O(n), Space O(1).\n   */\n  forEach(callbackfn: ElementCallback<E, R, void>, thisArg?: unknown): void {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        callbackfn(item, index++, this);\n      } else {\n        const fn = callbackfn as (this: unknown, v: E, i: number, self: this) => void;\n        fn.call(thisArg, item, index++, this);\n      }\n    }\n  }\n\n  /**\n   * Finds the first element that satisfies the predicate and returns it.\n   *\n   * @overload\n   * Finds the first element of type `S` (a subtype of `E`) that satisfies the predicate and returns it.\n   * @template S\n   * @param predicate Type-guard predicate: `(value, index, self) => value is S`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns The matched element typed as `S`, or `undefined` if not found.\n   *\n   * @overload\n   * @param predicate Boolean predicate: `(value, index, self) => boolean`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns The first matching element as `E`, or `undefined` if not found.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early on the first match. Space O(1).\n   */\n  find<S extends E>(predicate: ElementCallback<E, R, S>, thisArg?: unknown): S | undefined;\n  find(predicate: ElementCallback<E, R, unknown>, thisArg?: unknown): E | undefined;\n\n  // Implementation signature\n  find(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): E | undefined {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (predicate(item, index++, this)) return item;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (fn.call(thisArg, item, index++, this)) return item;\n      }\n    }\n    return;\n  }\n\n  /**\n   * Checks whether a strictly-equal element exists in the structure.\n   *\n   * @param element The element to test with `===` equality.\n   * @returns `true` if an equal element is found; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case. Space O(1).\n   */\n  has(element: E): boolean {\n    for (const ele of this) if (ele === element) return true;\n    return false;\n  }\n\n  reduce(callbackfn: ReduceElementCallback<E, R>): E;\n  reduce(callbackfn: ReduceElementCallback<E, R>, initialValue: E): E;\n  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue: U): U;\n\n  /**\n   * Reduces all elements to a single accumulated value.\n   *\n   * @overload\n   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`. The first element is used as the initial accumulator.\n   * @returns The final accumulated value typed as `E`.\n   *\n   * @overload\n   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`.\n   * @param initialValue The initial accumulator value of type `E`.\n   * @returns The final accumulated value typed as `E`.\n   *\n   * @overload\n   * @template U The accumulator type when it differs from `E`.\n   * @param callbackfn Reducer of signature `(acc: U, value, index, self) => U`.\n   * @param initialValue The initial accumulator value of type `U`.\n   * @returns The final accumulated value typed as `U`.\n   *\n   * @remarks\n   * Time O(n), Space O(1). Throws if called on an empty structure without `initialValue`.\n   */\n  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue?: U): U {\n    let index = 0;\n    const iter = this[Symbol.iterator]();\n    let acc: U;\n\n    if (arguments.length >= 2) {\n      acc = initialValue as U;\n    } else {\n      const first = iter.next();\n      if (first.done) throw new TypeError('Reduce of empty structure with no initial value');\n      acc = first.value as unknown as U;\n      index = 1;\n    }\n\n    for (const value of iter) {\n      acc = callbackfn(acc, value, index++, this);\n    }\n    return acc;\n  }\n\n  /**\n   * Materializes the elements into a new array.\n   *\n   * @returns A shallow array copy of the iteration order.\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  toArray(): E[] {\n    return [...this];\n  }\n\n  /**\n   * Returns a representation of the structure suitable for quick visualization.\n   * Defaults to an array of elements; subclasses may override to provide richer visuals.\n   *\n   * @returns A visual representation (array by default).\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  toVisual(): E[] {\n    return [...this];\n  }\n\n  /**\n   * Prints `toVisual()` to the console. Intended for quick debugging.\n   *\n   * @returns `void`.\n   * @remarks\n   * Time O(n) due to materialization, Space O(n) for the intermediate representation.\n   */\n  print(): void {\n    console.log(this.toVisual());\n  }\n\n  /**\n   * Indicates whether the structure currently contains no elements.\n   *\n   * @returns `true` if empty; otherwise `false`.\n   * @remarks\n   * Expected Time O(1), Space O(1) for most implementations.\n   */\n  abstract isEmpty(): boolean;\n\n  /**\n   * Removes all elements from the structure.\n   *\n   * @returns `void`.\n   * @remarks\n   * Expected Time O(1) or O(n) depending on the implementation; Space O(1).\n   */\n  abstract clear(): void;\n\n  /**\n   * Creates a structural copy with the same element values and configuration.\n   *\n   * @returns A clone of the current instance (same concrete type).\n   * @remarks\n   * Expected Time O(n) to copy elements; Space O(n).\n   */\n  abstract clone(): this;\n\n  /**\n   * Maps each element to a new element and returns a new iterable structure.\n   *\n   * @template EM The mapped element type.\n   * @template RM The mapped raw element type used internally by the target structure.\n   * @param callback Function with signature `(value, index, self) => mapped`.\n   * @param options Optional options for the returned structure, including its `toElementFn`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns A new `IterableElementBase<EM, RM>` containing mapped elements.\n   *\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  abstract map<EM, RM>(\n    callback: ElementCallback<E, R, EM>,\n    options?: IterableElementBaseOptions<EM, RM>,\n    thisArg?: unknown\n  ): IterableElementBase<EM, RM>;\n\n  /**\n   * Maps each element to the same element type and returns the same concrete structure type.\n   *\n   * @param callback Function with signature `(value, index, self) => mappedValue`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns A new instance of the same concrete type with mapped elements.\n   *\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  abstract mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;\n\n  /**\n   * Filters elements using the provided predicate and returns the same concrete structure type.\n   *\n   * @param predicate Function with signature `(value, index, self) => boolean`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns A new instance of the same concrete type containing only elements that pass the predicate.\n   *\n   * @remarks\n   * Time O(n), Space O(k) where `k` is the number of kept elements.\n   */\n  abstract filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this;\n\n  /**\n   * Internal iterator factory used by the default iterator.\n   *\n   * @param args Optional iterator arguments.\n   * @returns An iterator over elements.\n   *\n   * @remarks\n   * Implementations should yield in O(1) per element with O(1) extra space when possible.\n   */\n  protected abstract _getIterator(...args: unknown[]): IterableIterator<E>;\n}\n","/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\n\nimport type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '../../types';\nimport { IterableElementBase } from '../base';\n\n/**\n * Binary heap with pluggable comparator; supports fast insertion and removal of the top element.\n * @remarks Time O(1), Space O(1)\n * @template E\n * @template R\n * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.\n * 2. Heap Properties: Each node in a heap follows a specific order property, which varies depending on the type of heap:\n * Max Heap: The value of each parent node is greater than or equal to the value of its children.\n * Min Heap: The value of each parent node is less than or equal to the value of its children.\n * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.\n * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).\n * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.\n * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.\n * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.\n * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.\n * @example\n * // basic Heap creation and add operation\n *  // Create a min heap (default)\n *     const minHeap = new Heap([5, 3, 7, 1, 9, 2]);\n *\n *     // Verify size\n *     console.log(minHeap.size); // 6;\n *\n *     // Add new element\n *     minHeap.add(4);\n *     console.log(minHeap.size); // 7;\n *\n *     // Min heap property: smallest element at root\n *     const min = minHeap.peek();\n *     console.log(min); // 1;\n * @example\n * // Heap with custom comparator (MaxHeap behavior)\n *  interface Task {\n *       id: number;\n *       priority: number;\n *       name: string;\n *     }\n *\n *     // Custom comparator for max heap behavior (higher priority first)\n *     const tasks: Task[] = [\n *       { id: 1, priority: 5, name: 'Email' },\n *       { id: 2, priority: 3, name: 'Chat' },\n *       { id: 3, priority: 8, name: 'Alert' }\n *     ];\n *\n *     const maxHeap = new Heap(tasks, {\n *       comparator: (a: Task, b: Task) => b.priority - a.priority\n *     });\n *\n *     console.log(maxHeap.size); // 3;\n *\n *     // Peek returns highest priority task\n *     const topTask = maxHeap.peek();\n *     console.log(topTask?.priority); // 8;\n *     console.log(topTask?.name); // 'Alert';\n * @example\n * // Heap for event processing with priority\n *  interface Event {\n *       id: number;\n *       type: 'critical' | 'warning' | 'info';\n *       timestamp: number;\n *       message: string;\n *     }\n *\n *     // Custom priority: critical > warning > info\n *     const priorityMap = { critical: 3, warning: 2, info: 1 };\n *\n *     const eventHeap = new Heap<Event>([], {\n *       comparator: (a: Event, b: Event) => {\n *         const priorityA = priorityMap[a.type];\n *         const priorityB = priorityMap[b.type];\n *         return priorityB - priorityA; // Higher priority first\n *       }\n *     });\n *\n *     // Add events in random order\n *     eventHeap.add({ id: 1, type: 'info', timestamp: 100, message: 'User logged in' });\n *     eventHeap.add({ id: 2, type: 'critical', timestamp: 101, message: 'Server down' });\n *     eventHeap.add({ id: 3, type: 'warning', timestamp: 102, message: 'High memory' });\n *     eventHeap.add({ id: 4, type: 'info', timestamp: 103, message: 'Cache cleared' });\n *     eventHeap.add({ id: 5, type: 'critical', timestamp: 104, message: 'Database error' });\n *\n *     console.log(eventHeap.size); // 5;\n *\n *     // Process events by priority (critical first)\n *     const processedOrder: Event[] = [];\n *     while (eventHeap.size > 0) {\n *       const event = eventHeap.poll();\n *       if (event) {\n *         processedOrder.push(event);\n *       }\n *     }\n *\n *     // Verify critical events came first\n *     console.log(processedOrder[0].type); // 'critical';\n *     console.log(processedOrder[1].type); // 'critical';\n *     console.log(processedOrder[2].type); // 'warning';\n *     console.log(processedOrder[3].type); // 'info';\n *     console.log(processedOrder[4].type); // 'info';\n *\n *     // Verify O(log n) operations\n *     const newHeap = new Heap<number>([5, 3, 7, 1]);\n *\n *     // Add - O(log n)\n *     newHeap.add(2);\n *     console.log(newHeap.size); // 5;\n *\n *     // Poll - O(log n)\n *     const removed = newHeap.poll();\n *     console.log(removed); // 1;\n *\n *     // Peek - O(1)\n *     const top = newHeap.peek();\n *     console.log(top); // 2;\n * @example\n * // Use Heap to solve top k problems\n *  function topKElements(arr: number[], k: number): number[] {\n *       const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap\n *       arr.forEach(num => {\n *         heap.add(num);\n *         if (heap.size > k) heap.poll(); // Keep the heap size at K\n *       });\n *       return heap.toArray();\n *     }\n *\n *     const numbers = [10, 30, 20, 5, 15, 25];\n *     console.log(topKElements(numbers, 3)); // [15, 10, 5];\n * @example\n * // Use Heap to dynamically maintain the median\n *  class MedianFinder {\n *       private low: MaxHeap<number>; // Max heap, stores the smaller half\n *       private high: MinHeap<number>; // Min heap, stores the larger half\n *\n *       constructor() {\n *         this.low = new MaxHeap<number>([]);\n *         this.high = new MinHeap<number>([]);\n *       }\n *\n *       addNum(num: number): void {\n *         if (this.low.isEmpty() || num <= this.low.peek()!) this.low.add(num);\n *         else this.high.add(num);\n *\n *         // Balance heaps\n *         if (this.low.size > this.high.size + 1) this.high.add(this.low.poll()!);\n *         else if (this.high.size > this.low.size) this.low.add(this.high.poll()!);\n *       }\n *\n *       findMedian(): number {\n *         if (this.low.size === this.high.size) return (this.low.peek()! + this.high.peek()!) / 2;\n *         return this.low.peek()!;\n *       }\n *     }\n *\n *     const medianFinder = new MedianFinder();\n *     medianFinder.addNum(10);\n *     console.log(medianFinder.findMedian()); // 10;\n *     medianFinder.addNum(20);\n *     console.log(medianFinder.findMedian()); // 15;\n *     medianFinder.addNum(30);\n *     console.log(medianFinder.findMedian()); // 20;\n *     medianFinder.addNum(40);\n *     console.log(medianFinder.findMedian()); // 25;\n *     medianFinder.addNum(50);\n *     console.log(medianFinder.findMedian()); // 30;\n * @example\n * // Use Heap for load balancing\n *  function loadBalance(requests: number[], servers: number): number[] {\n *       const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap\n *       const serverLoads = new Array(servers).fill(0);\n *\n *       for (let i = 0; i < servers; i++) {\n *         serverHeap.add({ id: i, load: 0 });\n *       }\n *\n *       requests.forEach(req => {\n *         const server = serverHeap.poll()!;\n *         serverLoads[server.id] += req;\n *         server.load += req;\n *         serverHeap.add(server); // The server after updating the load is re-entered into the heap\n *       });\n *\n *       return serverLoads;\n *     }\n *\n *     const requests = [5, 2, 8, 3, 7];\n *     console.log(loadBalance(requests, 3)); // [12, 8, 5];\n * @example\n * // Use Heap to schedule tasks\n *  type Task = [string, number];\n *\n *     function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {\n *       const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap\n *       const allocation = new Map<number, Task[]>();\n *\n *       // Initialize the load on each machine\n *       for (let i = 0; i < machines; i++) {\n *         machineHeap.add({ id: i, load: 0 });\n *         allocation.set(i, []);\n *       }\n *\n *       // Assign tasks\n *       tasks.forEach(([task, load]) => {\n *         const machine = machineHeap.poll()!;\n *         allocation.get(machine.id)!.push([task, load]);\n *         machine.load += load;\n *         machineHeap.add(machine); // The machine after updating the load is re-entered into the heap\n *       });\n *\n *       return allocation;\n *     }\n *\n *     const tasks: Task[] = [\n *       ['Task1', 3],\n *       ['Task2', 1],\n *       ['Task3', 2],\n *       ['Task4', 5],\n *       ['Task5', 4]\n *     ];\n *     const expectedMap = new Map<number, Task[]>();\n *     expectedMap.set(0, [\n *       ['Task1', 3],\n *       ['Task4', 5]\n *     ]);\n *     expectedMap.set(1, [\n *       ['Task2', 1],\n *       ['Task3', 2],\n *       ['Task5', 4]\n *     ]);\n *     console.log(scheduleTasks(tasks, 2)); // expectedMap;\n */\nexport class Heap<E = any, R = any> extends IterableElementBase<E, R> {\n  protected _equals: (a: E, b: E) => boolean = Object.is;\n\n  /**\n   * Create a Heap and optionally bulk-insert elements.\n   * @remarks Time O(N), Space O(N)\n   * @param [elements] - Iterable of elements (or raw values if toElementFn is set).\n   * @param [options] - Options such as comparator and toElementFn.\n   * @returns New Heap instance.\n   */\n\n  constructor(elements: Iterable<E | R> = [], options?: HeapOptions<E, R>) {\n    super(options);\n\n    if (options) {\n      const { comparator } = options;\n      if (comparator) this._comparator = comparator;\n    }\n\n    this.addMany(elements as Iterable<E | R>);\n  }\n\n  protected _elements: E[] = [];\n\n  /**\n   * Get the backing array of the heap.\n   * @remarks Time O(1), Space O(1)\n   * @returns Internal elements array.\n   */\n\n  get elements(): E[] {\n    return this._elements;\n  }\n\n  /**\n   * Get the number of elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns Heap size.\n   */\n\n  get size(): number {\n    return this.elements.length;\n  }\n\n  /**\n   * Get the last leaf element.\n   * @remarks Time O(1), Space O(1)\n   * @returns Last element or undefined.\n   */\n\n  get leaf(): E | undefined {\n    return this.elements[this.size - 1] ?? undefined;\n  }\n\n  /**\n   * Create a heap of the same class from an iterable.\n   * @remarks Time O(N), Space O(N)\n   * @template T\n   * @template R\n   * @template S\n   * @param [elements] - Iterable of elements or raw records.\n   * @param [options] - Heap options including comparator.\n   * @returns A new heap instance of this class.\n   */\n\n  static from<T, R = any, S extends Heap<T, R> = Heap<T, R>>(\n    this: new (elements?: Iterable<T | R>, options?: HeapOptions<T, R>) => S,\n    elements?: Iterable<T | R>,\n    options?: HeapOptions<T, R>\n  ): S {\n    return new this(elements, options);\n  }\n\n  /**\n   * Build a Heap from an iterable in linear time given a comparator.\n   * @remarks Time O(N), Space O(N)\n   * @template EE\n   * @template RR\n   * @param elements - Iterable of elements.\n   * @param options - Heap options including comparator.\n   * @returns A new Heap built from elements.\n   */\n\n  static heapify<EE = any, RR = any>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {\n    return new Heap<EE, RR>(elements, options);\n  }\n\n  /**\n   * Insert an element.\n   * @remarks Time O(1) amortized, Space O(1)\n   * @param element - Element to insert.\n   * @returns True.\n   */\n\n  add(element: E): boolean {\n    this._elements.push(element);\n    return this._bubbleUp(this.elements.length - 1);\n  }\n\n  /**\n   * Insert many elements from an iterable.\n   * @remarks Time O(N log N), Space O(1)\n   * @param elements - Iterable of elements or raw values.\n   * @returns Array of per-element success flags.\n   */\n\n  addMany(elements: Iterable<E | R>): boolean[] {\n    const flags: boolean[] = [];\n    for (const el of elements) {\n      if (this.toElementFn) {\n        const ok = this.add(this.toElementFn(el as R));\n        flags.push(ok);\n      } else {\n        const ok = this.add(el as E);\n        flags.push(ok);\n      }\n    }\n    return flags;\n  }\n\n  /**\n   * Remove and return the top element.\n   * @remarks Time O(log N), Space O(1)\n   * @returns Top element or undefined.\n   */\n\n  poll(): E | undefined {\n    if (this.elements.length === 0) return;\n    const value = this.elements[0];\n    const last = this.elements.pop()!;\n    if (this.elements.length) {\n      this.elements[0] = last;\n      this._sinkDown(0, this.elements.length >> 1);\n    }\n    return value;\n  }\n\n  /**\n   * Get the current top element without removing it.\n   * @remarks Time O(1), Space O(1)\n   * @returns Top element or undefined.\n   */\n\n  peek(): E | undefined {\n    return this.elements[0];\n  }\n\n  /**\n   * Check whether the heap is empty.\n   * @remarks Time O(1), Space O(1)\n   * @returns True if size is 0.\n   */\n\n  isEmpty(): boolean {\n    return this.size === 0;\n  }\n\n  /**\n   * Remove all elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns void\n   */\n\n  clear(): void {\n    this._elements = [];\n  }\n\n  /**\n   * Replace the backing array and rebuild the heap.\n   * @remarks Time O(N), Space O(N)\n   * @param elements - Iterable used to refill the heap.\n   * @returns Array of per-node results from fixing steps.\n   */\n\n  refill(elements: Iterable<E>): boolean[] {\n    this._elements = Array.from(elements);\n    return this.fix();\n  }\n\n  /**\n   * Check if an equal element exists in the heap.\n   * @remarks Time O(N), Space O(1)\n   * @param element - Element to search for.\n   * @returns True if found.\n   */\n\n  override has(element: E): boolean {\n    for (const el of this.elements) if (this._equals(el, element)) return true;\n    return false;\n  }\n\n  /**\n   * Delete one occurrence of an element.\n   * @remarks Time O(N), Space O(1)\n   * @param element - Element to delete.\n   * @returns True if an element was removed.\n   */\n\n  delete(element: E): boolean {\n    let index = -1;\n    for (let i = 0; i < this.elements.length; i++) {\n      if (this._equals(this.elements[i], element)) {\n        index = i;\n        break;\n      }\n    }\n    if (index < 0) return false;\n    if (index === 0) {\n      this.poll();\n    } else if (index === this.elements.length - 1) {\n      this.elements.pop();\n    } else {\n      this.elements.splice(index, 1, this.elements.pop()!);\n      this._bubbleUp(index);\n      this._sinkDown(index, this.elements.length >> 1);\n    }\n    return true;\n  }\n\n  /**\n   * Delete the first element that matches a predicate.\n   * @remarks Time O(N), Space O(1)\n   * @param predicate - Function (element, index, heap) → boolean.\n   * @returns True if an element was removed.\n   */\n\n  deleteBy(predicate: (element: E, index: number, heap: this) => boolean): boolean {\n    let idx = -1;\n    for (let i = 0; i < this.elements.length; i++) {\n      if (predicate(this.elements[i], i, this)) {\n        idx = i;\n        break;\n      }\n    }\n    if (idx < 0) return false;\n    if (idx === 0) {\n      this.poll();\n    } else if (idx === this.elements.length - 1) {\n      this.elements.pop();\n    } else {\n      this.elements.splice(idx, 1, this.elements.pop()!);\n      this._bubbleUp(idx);\n      this._sinkDown(idx, this.elements.length >> 1);\n    }\n    return true;\n  }\n\n  /**\n   * Set the equality comparator used by has/delete operations.\n   * @remarks Time O(1), Space O(1)\n   * @param equals - Equality predicate (a, b) → boolean.\n   * @returns This heap.\n   */\n\n  setEquality(equals: (a: E, b: E) => boolean): this {\n    this._equals = equals;\n    return this;\n  }\n\n  /**\n   * Traverse the binary heap as a complete binary tree and collect elements.\n   * @remarks Time O(N), Space O(H)\n   * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.\n   * @returns Array of visited elements.\n   */\n\n  dfs(order: DFSOrderPattern = 'PRE'): E[] {\n    const result: E[] = [];\n    const _dfs = (index: number) => {\n      const left = 2 * index + 1,\n        right = left + 1;\n      if (index < this.size) {\n        if (order === 'IN') {\n          _dfs(left);\n          result.push(this.elements[index]);\n          _dfs(right);\n        } else if (order === 'PRE') {\n          result.push(this.elements[index]);\n          _dfs(left);\n          _dfs(right);\n        } else if (order === 'POST') {\n          _dfs(left);\n          _dfs(right);\n          result.push(this.elements[index]);\n        }\n      }\n    };\n    _dfs(0);\n    return result;\n  }\n\n  /**\n   * Restore heap order bottom-up (heapify in-place).\n   * @remarks Time O(N), Space O(1)\n   * @returns Array of per-node results from fixing steps.\n   */\n\n  fix(): boolean[] {\n    const results: boolean[] = [];\n    for (let i = Math.floor(this.size / 2) - 1; i >= 0; i--) {\n      results.push(this._sinkDown(i, this.elements.length >> 1));\n    }\n    return results;\n  }\n\n  /**\n   * Return all elements in ascending order by repeatedly polling.\n   * @remarks Time O(N log N), Space O(N)\n   * @returns Sorted array of elements.\n   */\n\n  sort(): E[] {\n    const visited: E[] = [];\n    const cloned = this._createInstance();\n    for (const x of this.elements) cloned.add(x);\n    while (!cloned.isEmpty()) {\n      const top = cloned.poll();\n      if (top !== undefined) visited.push(top);\n    }\n    return visited;\n  }\n\n  /**\n   * Deep clone this heap.\n   * @remarks Time O(N), Space O(N)\n   * @returns A new heap with the same elements.\n   */\n\n  clone(): this {\n    const next = this._createInstance();\n    for (const x of this.elements) next.add(x);\n    return next;\n  }\n\n  /**\n   * Filter elements into a new heap of the same class.\n   * @remarks Time O(N log N), Space O(N)\n   * @param callback - Predicate (element, index, heap) → boolean to keep element.\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new heap with the kept elements.\n   */\n\n  filter(callback: ElementCallback<E, R, boolean>, thisArg?: unknown): this {\n    const out = this._createInstance();\n    let i = 0;\n    for (const x of this) {\n      if (thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this)) {\n        out.add(x);\n      } else {\n        i++;\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Map elements into a new heap of possibly different element type.\n   * @remarks Time O(N log N), Space O(N)\n   * @template EM\n   * @template RM\n   * @param callback - Mapping function (element, index, heap) → newElement.\n   * @param options - Options for the output heap, including comparator for EM.\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new heap with mapped elements.\n   */\n\n  map<EM, RM>(\n    callback: ElementCallback<E, R, EM>,\n    options: HeapOptions<EM, RM> & { comparator: Comparator<EM> },\n    thisArg?: unknown\n  ): Heap<EM, RM> {\n    const { comparator, toElementFn, ...rest } = options ?? {};\n    if (!comparator) throw new TypeError('Heap.map requires options.comparator for EM');\n    const out = this._createLike<EM, RM>([], { ...rest, comparator, toElementFn });\n    let i = 0;\n    for (const x of this) {\n      const v = thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);\n      out.add(v);\n    }\n    return out;\n  }\n\n  /**\n   * Map elements into a new heap of the same element type.\n   * @remarks Time O(N log N), Space O(N)\n   * @param callback - Mapping function (element, index, heap) → element.\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new heap with mapped elements.\n   */\n\n  mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this {\n    const out = this._createInstance();\n    let i = 0;\n    for (const x of this) {\n      const v = thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);\n      out.add(v);\n    }\n    return out;\n  }\n\n  protected readonly _DEFAULT_COMPARATOR: Comparator<E> = (a: E, b: E): number => {\n    if (typeof a === 'object' || typeof b === 'object') {\n      throw TypeError('When comparing object types, define a custom comparator in options.');\n    }\n    if (a > b) return 1;\n    if (a < b) return -1;\n    return 0;\n  };\n\n  protected readonly _comparator: Comparator<E> = this._DEFAULT_COMPARATOR;\n\n  /**\n   * Get the comparator used to order elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns Comparator function.\n   */\n\n  get comparator() {\n    return this._comparator;\n  }\n\n  protected *_getIterator(): IterableIterator<E> {\n    for (const element of this.elements) yield element;\n  }\n\n  protected _bubbleUp(index: number): boolean {\n    const element = this.elements[index];\n    while (index > 0) {\n      const parent = (index - 1) >> 1;\n      const parentItem = this.elements[parent];\n      if (this.comparator(parentItem, element) <= 0) break;\n      this.elements[index] = parentItem;\n      index = parent;\n    }\n    this.elements[index] = element;\n    return true;\n  }\n\n  protected _sinkDown(index: number, halfLength: number): boolean {\n    const element = this.elements[index];\n    while (index < halfLength) {\n      let left = (index << 1) | 1;\n      const right = left + 1;\n      let minItem = this.elements[left];\n      if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {\n        left = right;\n        minItem = this.elements[right];\n      }\n      if (this.comparator(minItem, element) >= 0) break;\n      this.elements[index] = minItem;\n      index = left;\n    }\n    this.elements[index] = element;\n    return true;\n  }\n\n  /**\n   * (Protected) Create an empty instance of the same concrete class.\n   * @remarks Time O(1), Space O(1)\n   * @param [options] - Options to override comparator or toElementFn.\n   * @returns A like-kind empty heap instance.\n   */\n\n  protected _createInstance(options?: HeapOptions<E, R>): this {\n    const Ctor = this.constructor as new (\n      elements?: Iterable<E> | Iterable<R>,\n      options?: HeapOptions<E, R>\n    ) => this;\n    return new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...(options ?? {}) });\n  }\n\n  /**\n   * (Protected) Create a like-kind instance seeded by elements.\n   * @remarks Time O(N log N), Space O(N)\n   * @template EM\n   * @template RM\n   * @param [elements] - Iterable of elements or raw values to seed.\n   * @param [options] - Options forwarded to the constructor.\n   * @returns A like-kind heap instance.\n   */\n\n  protected _createLike<EM, RM>(\n    elements: Iterable<EM> | Iterable<RM> = [],\n    options?: HeapOptions<EM, RM>\n  ): Heap<EM, RM> {\n    const Ctor = this.constructor as new (\n      elements?: Iterable<EM> | Iterable<RM>,\n      options?: HeapOptions<EM, RM>\n    ) => Heap<EM, RM>;\n    return new Ctor(elements, options);\n  }\n\n  /**\n   * (Protected) Spawn an empty like-kind heap instance.\n   * @remarks Time O(1), Space O(1)\n   * @template EM\n   * @template RM\n   * @param [options] - Options forwarded to the constructor.\n   * @returns An empty like-kind heap instance.\n   */\n\n  protected _spawnLike<EM, RM>(options?: HeapOptions<EM, RM>): Heap<EM, RM> {\n    return this._createLike<EM, RM>([], options);\n  }\n}\n\n/**\n * Node container used by FibonacciHeap.\n * @remarks Time O(1), Space O(1)\n * @template E\n */\nexport class FibonacciHeapNode<E> {\n  element: E;\n  degree: number;\n  left?: FibonacciHeapNode<E>;\n  right?: FibonacciHeapNode<E>;\n  child?: FibonacciHeapNode<E>;\n  parent?: FibonacciHeapNode<E>;\n  marked: boolean;\n\n  constructor(element: E, degree = 0) {\n    this.element = element;\n    this.degree = degree;\n    this.marked = false;\n  }\n}\n\n/**\n * Fibonacci heap (min-heap) optimized for fast merges and amortized operations.\n * @remarks Time O(1), Space O(1)\n * @template E\n * @example examples will be generated by unit test\n */\nexport class FibonacciHeap<E> {\n  /**\n   * Create a FibonacciHeap.\n   * @remarks Time O(1), Space O(1)\n   * @param [comparator] - Comparator to order elements (min-heap by default).\n   * @returns New FibonacciHeap instance.\n   */\n\n  constructor(comparator?: Comparator<E>) {\n    this.clear();\n    this._comparator = comparator || this._defaultComparator;\n    if (typeof this.comparator !== 'function') throw new Error('FibonacciHeap: comparator must be a function.');\n  }\n\n  protected _root?: FibonacciHeapNode<E>;\n\n  /**\n   * Get the circular root list head.\n   * @remarks Time O(1), Space O(1)\n   * @returns Root node or undefined.\n   */\n\n  get root(): FibonacciHeapNode<E> | undefined {\n    return this._root;\n  }\n\n  protected _size = 0;\n  get size(): number {\n    return this._size;\n  }\n\n  protected _min?: FibonacciHeapNode<E>;\n\n  /**\n   * Get the current minimum node.\n   * @remarks Time O(1), Space O(1)\n   * @returns Min node or undefined.\n   */\n\n  get min(): FibonacciHeapNode<E> | undefined {\n    return this._min;\n  }\n\n  protected readonly _comparator: Comparator<E>;\n\n  get comparator(): Comparator<E> {\n    return this._comparator;\n  }\n\n  clear(): void {\n    this._root = undefined;\n    this._min = undefined;\n    this._size = 0;\n  }\n\n  add(element: E): boolean {\n    this.push(element);\n    return true;\n  }\n\n  /**\n   * Push an element into the root list.\n   * @remarks Time O(1) amortized, Space O(1)\n   * @param element - Element to insert.\n   * @returns This heap.\n   */\n\n  push(element: E): this {\n    const node = this.createNode(element);\n    node.left = node;\n    node.right = node;\n    this.mergeWithRoot(node);\n    if (!this.min || this.comparator(node.element, this.min.element) <= 0) this._min = node;\n    this._size++;\n    return this;\n  }\n\n  peek(): E | undefined {\n    return this.min ? this.min.element : undefined;\n  }\n\n  /**\n   * Collect nodes from a circular doubly linked list starting at head.\n   * @remarks Time O(K), Space O(K)\n   * @param [head] - Start node of the circular list.\n   * @returns Array of nodes from the list.\n   */\n\n  consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[] {\n    const elements: FibonacciHeapNode<E>[] = [];\n    if (!head) return elements;\n    let node: FibonacciHeapNode<E> | undefined = head;\n    let started = false;\n    while (true) {\n      if (node === head && started) break;\n      else if (node === head) started = true;\n      elements.push(node!);\n      node = node!.right;\n    }\n    return elements;\n  }\n\n  /**\n   * Insert a node into a parent's child list (circular).\n   * @remarks Time O(1), Space O(1)\n   * @param parent - Parent node.\n   * @param node - Child node to insert.\n   * @returns void\n   */\n\n  mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void {\n    if (!parent.child) parent.child = node;\n    else {\n      node.right = parent.child.right;\n      node.left = parent.child;\n      parent.child.right!.left = node;\n      parent.child.right = node;\n    }\n  }\n\n  poll(): E | undefined {\n    return this.pop();\n  }\n\n  /**\n   * Remove and return the minimum element, consolidating the root list.\n   * @remarks Time O(log N) amortized, Space O(1)\n   * @returns Minimum element or undefined.\n   */\n\n  pop(): E | undefined {\n    if (this._size === 0) return undefined;\n    const z = this.min!;\n    if (z.child) {\n      const elements = this.consumeLinkedList(z.child);\n      for (const node of elements) {\n        this.mergeWithRoot(node);\n        node.parent = undefined;\n      }\n    }\n    this.removeFromRoot(z);\n    if (z === z.right) {\n      this._min = undefined;\n      this._root = undefined;\n    } else {\n      this._min = z.right;\n      this._consolidate();\n    }\n    this._size--;\n    return z.element;\n  }\n\n  /**\n   * Meld another heap into this heap.\n   * @remarks Time O(1), Space O(1)\n   * @param heapToMerge - Another FibonacciHeap to meld into this one.\n   * @returns void\n   */\n\n  merge(heapToMerge: FibonacciHeap<E>): void {\n    if (heapToMerge.size === 0) return;\n    if (this.root && heapToMerge.root) {\n      const thisRoot = this.root,\n        otherRoot = heapToMerge.root;\n      const thisRootRight = thisRoot.right!,\n        otherRootLeft = otherRoot.left!;\n      thisRoot.right = otherRoot;\n      otherRoot.left = thisRoot;\n      thisRootRight.left = otherRootLeft;\n      otherRootLeft.right = thisRootRight;\n    } else if (!this.root && heapToMerge.root) {\n      this._root = heapToMerge.root;\n    }\n    if (!this.min || (heapToMerge.min && this.comparator(heapToMerge.min.element, this.min.element) < 0)) {\n      this._min = heapToMerge.min;\n    }\n    this._size += heapToMerge.size;\n    heapToMerge.clear();\n  }\n\n  createNode(element: E): FibonacciHeapNode<E> {\n    return new FibonacciHeapNode<E>(element);\n  }\n\n  isEmpty(): boolean {\n    return this._size === 0;\n  }\n\n  protected _defaultComparator(a: E, b: E): number {\n    if (a < b) return -1;\n    if (a > b) return 1;\n    return 0;\n  }\n\n  protected mergeWithRoot(node: FibonacciHeapNode<E>): void {\n    if (!this.root) this._root = node;\n    else {\n      node.right = this.root.right;\n      node.left = this.root;\n      this.root.right!.left = node;\n      this.root.right = node;\n    }\n  }\n\n  protected removeFromRoot(node: FibonacciHeapNode<E>): void {\n    if (this.root === node) this._root = node.right;\n    if (node.left) node.left.right = node.right;\n    if (node.right) node.right.left = node.left;\n  }\n\n  protected _link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {\n    this.removeFromRoot(y);\n    y.left = y;\n    y.right = y;\n    this.mergeWithChild(x, y);\n    x.degree++;\n    y.parent = x;\n  }\n\n  protected _consolidate(): void {\n    const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this._size);\n    const elements = this.consumeLinkedList(this.root);\n    let x: FibonacciHeapNode<E> | undefined,\n      y: FibonacciHeapNode<E> | undefined,\n      d: number,\n      t: FibonacciHeapNode<E> | undefined;\n\n    for (const node of elements) {\n      x = node;\n      d = x.degree;\n      while (A[d]) {\n        y = A[d] as FibonacciHeapNode<E>;\n        if (this.comparator(x.element, y.element) > 0) {\n          t = x;\n          x = y;\n          y = t;\n        }\n        this._link(y, x);\n        A[d] = undefined;\n        d++;\n      }\n      A[d] = x;\n    }\n\n    for (let i = 0; i < A.length; i++) {\n      if (A[i] && (!this.min || this.comparator(A[i]!.element, this.min.element) <= 0)) this._min = A[i]!;\n    }\n  }\n}\n","/**\n * data-structure-typed\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\nimport type { HeapOptions } from '../../types';\nimport { Heap } from './heap';\n\n/**\n * @template E\n * @template R\n * Max-oriented binary heap.\n * Notes and typical use-cases are documented in {@link Heap}.\n *\n * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.\n * 2. Heap Properties: The value of each parent node is greater than or equal to the value of its children.\n * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.\n * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).\n * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.\n * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.\n * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.\n * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum-spanning tree algorithm, which use heaps to improve performance.\n * @example\n */\nexport class MaxHeap<E = any, R = any> extends Heap<E, R> {\n  /**\n   * Create a max-heap. For objects, supply a custom comparator.\n   * @param elements Optional initial elements.\n   * @param options Optional configuration.\n   */\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: HeapOptions<E, R>) {\n    super(elements, {\n      comparator: (a: E, b: E): number => {\n        if (typeof a === 'object' || typeof b === 'object') {\n          throw TypeError(\n            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`\n          );\n        }\n        if (a < b) return 1;\n        if (a > b) return -1;\n        return 0;\n      },\n      ...options\n    });\n  }\n}\n","/**\n * @remarks Time O(n log n), Space O(n).\n * data-structure-typed\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\nimport type { HeapOptions } from '../../types';\nimport { Heap } from './heap';\n\n/**\n * @template E\n * @template R\n * Min-oriented binary heap.\n * Notes and typical use-cases are documented in {@link Heap}.\n *\n * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.\n * 2. MinHeap Properties:  The value of each parent node is less than or equal to the value of its children.\n * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.\n * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).\n * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.\n * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.\n * 7. Efficient Sorting Algorithms: For example, heap sort. MinHeap sort uses the properties of a heap to sort elements.\n * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.\n * @example\n */\nexport class MinHeap<E = any, R = any> extends Heap<E, R> {\n  /**\n   * Create a min-heap.\n   * @param elements Optional initial elements.\n   * @param options Optional configuration.\n   */\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: HeapOptions<E, R>) {\n    super(elements, options);\n  }\n}\n","/**\n * data-structure-typed\n *\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\n\nimport type { PriorityQueueOptions } from '../../types';\nimport { Heap } from '../heap';\n\n/**\n * @example\n */\nexport class PriorityQueue<E = any, R = any> extends Heap<E, R> {\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: PriorityQueueOptions<E, R>) {\n    super(elements, options);\n  }\n}\n","/**\n * data-structure-typed\n *\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\nimport type { PriorityQueueOptions } from '../../types';\nimport { PriorityQueue } from './priority-queue';\n\n/**\n * Min-oriented priority queue (min-heap) built on {@link PriorityQueue}.\n * The queue removes the smallest element first under the provided comparator.\n * Provide a custom comparator if you store non-primitive objects.\n * @template E Element type stored in the queue.\n * @template R Extra record/metadata associated with each element.\n * @example\n */\nexport class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {\n  /**\n   * Creates a min-priority queue.\n   * @param elements Optional initial elements to insert.\n   * @param options Optional configuration (e.g., `comparator`, `toElementFn`).\n   * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).\n   */\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: PriorityQueueOptions<E, R>) {\n    super(elements, options);\n  }\n}\n","/**\n * data-structure-typed\n *\n * @author Kirk Qi\n * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>\n * @license MIT License\n */\nimport type { PriorityQueueOptions } from '../../types';\nimport { PriorityQueue } from './priority-queue';\n\n/**\n * Max-oriented priority queue (max-heap) built on {@link PriorityQueue}.\n * The default comparator orders primitive values in descending order. If you store objects,\n * you must provide a custom comparator via {@link PriorityQueueOptions}.\n * @template E Element type stored in the queue.\n * @template R Extra record/metadata associated with each element.\n * @example\n */\nexport class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {\n  /**\n   * Creates a max-priority queue.\n   * @param elements Optional initial elements to insert.\n   * @param options Optional configuration (e.g., `comparator`, `toElementFn`).\n   * @throws {TypeError} Thrown when using the default comparator with object elements (provide a custom comparator).\n   * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).\n   */\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: PriorityQueueOptions<E, R>) {\n    super(elements, {\n      comparator: (a: E, b: E): number => {\n        if (typeof a === 'object' || typeof b === 'object') {\n          throw TypeError(\n            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`\n          );\n        }\n        if (a < b) return 1;\n        if (a > b) return -1;\n        return 0;\n      },\n      ...options\n    });\n  }\n}\n","export enum DFSOperation {\n  VISIT = 0,\n  PROCESS = 1\n}\n\nexport class Range<K> {\n  constructor(\n    public low: K,\n    public high: K,\n    public includeLow: boolean = true,\n    public includeHigh: boolean = true\n  ) {\n    // if (!(isComparable(low) && isComparable(high))) throw new RangeError('low or high is not comparable');\n    // if (low > high) throw new RangeError('low must be less than or equal to high');\n  }\n\n  // Determine whether a key is within the range\n  isInRange(key: K, comparator: (a: K, b: K) => number): boolean {\n    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;\n    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;\n    return lowCheck && highCheck;\n  }\n}\n"],"mappings":"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","names":["src_exports","__export","DFSOperation","FibonacciHeap","FibonacciHeapNode","Heap","MaxHeap","MaxPriorityQueue","MinHeap","MinPriorityQueue","PriorityQueue","Range","IterableElementBase","options","__publicField","toElementFn","args","item","predicate","thisArg","index","callbackfn","element","ele","initialValue","iter","acc","first","value","Heap","_Heap","IterableElementBase","elements","options","__publicField","a","b","comparator","_a","element","flags","el","ok","value","last","index","i","predicate","idx","equals","order","result","_dfs","left","right","results","visited","cloned","x","top","next","callback","thisArg","out","toElementFn","rest","v","parent","parentItem","halfLength","minItem","Ctor","FibonacciHeapNode","degree","FibonacciHeap","node","head","started","z","heapToMerge","thisRoot","otherRoot","thisRootRight","otherRootLeft","y","A","d","t","MaxHeap","Heap","elements","options","a","b","MinHeap","Heap","elements","options","PriorityQueue","Heap","elements","options","MinPriorityQueue","PriorityQueue","elements","options","MaxPriorityQueue","PriorityQueue","elements","options","a","b","DFSOperation","Range","low","high","includeLow","includeHigh","key","comparator","lowCheck","highCheck"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "priority-queue-typed",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "description": "Priority Queue",
   "browser": "dist/umd/priority-queue-typed.min.js",
   "umd:main": "dist/umd/priority-queue-typed.min.js",
@@ -158,6 +158,6 @@
     "typedoc": "^0.25.1"
   },
   "dependencies": {
-    "data-structure-typed": "^2.4.2"
+    "data-structure-typed": "^2.4.4"
   }
 }

package/src/data-structures/base/iterable-element-base.ts

@@ -35,7 +35,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
    * @remarks
    * Time O(1), Space O(1).
    */
-  protected _toElementFn?: (rawElement: R) => E;
+  protected readonly _toElementFn?: (rawElement: R) => E;
 
   /**
    * Exposes the current `toElementFn`, if configured.
@@ -229,7 +229,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
       index = 1;
     }
 
-    for (const value of iter as unknown as Iterable<E>) {
+    for (const value of iter) {
       acc = callbackfn(acc, value, index++, this);
     }
     return acc;

package/src/data-structures/binary-tree/binary-tree.ts

@@ -377,7 +377,7 @@ export class BinaryTree<K = any, V = any, R = any>
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
-  protected _isMapMode = true;
+  protected readonly _isMapMode: boolean = true;
 
   /**
    * Gets whether the tree is in Map mode.
@@ -389,7 +389,7 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._isMapMode;
   }
 
-  protected _isDuplicate = false;
+  protected readonly _isDuplicate: boolean = false;
 
   /**
    * Gets whether the tree allows duplicate keys.
@@ -440,7 +440,7 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._size;
   }
 
-  protected _NIL: BinaryTreeNode<K, V> = new BinaryTreeNode<K, V>(NaN as K) as unknown as BinaryTreeNode<K, V>;
+  protected readonly _NIL = new BinaryTreeNode<K, V>(NaN as K);
 
   /**
    * Gets the sentinel NIL node (used in self-balancing trees like Red-Black Tree).
@@ -452,7 +452,7 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._NIL;
   }
 
-  protected _toEntryFn?: ToEntryFn<K, V, R>;
+  protected readonly _toEntryFn?: ToEntryFn<K, V, R>;
 
   /**
    * Gets the function used to convert raw data objects (R) into [key, value] entries.
@@ -1014,7 +1014,7 @@ export class BinaryTree<K = any, V = any, R = any>
   ): BinaryTreeNode<K, V> | null | undefined {
     if (this._isMapMode && keyNodeEntryOrPredicate !== null && keyNodeEntryOrPredicate !== undefined) {
       if (!this._isPredicate(keyNodeEntryOrPredicate)) {
-        const key = this._extractKey(keyNodeEntryOrPredicate as any);
+        const key = this._extractKey(keyNodeEntryOrPredicate);
         if (key === null || key === undefined) return;
         return this._store.get(key);
       }
@@ -1078,7 +1078,7 @@ export class BinaryTree<K = any, V = any, R = any>
   ): boolean {
     if (this._isMapMode && keyNodeEntryOrPredicate !== undefined && keyNodeEntryOrPredicate !== null) {
       if (!this._isPredicate(keyNodeEntryOrPredicate)) {
-        const key = this._extractKey(keyNodeEntryOrPredicate as any);
+        const key = this._extractKey(keyNodeEntryOrPredicate);
         if (key === null || key === undefined) return false;
         return this._store.has(key);
       }
@@ -2136,7 +2136,8 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param node - The node.
    * @returns The node's key or undefined.
    */
-  protected _DEFAULT_NODE_CALLBACK = (node: BinaryTreeNode<K, V> | null | undefined) => (node ? node.key : undefined);
+  protected readonly _DEFAULT_NODE_CALLBACK: NodeCallback<BinaryTreeNode<K, V> | null | undefined, K | undefined> =
+    (node): K | undefined => node?.key;
 
   /**
    * (Protected) Snapshots the current tree's configuration options.

package/src/data-structures/binary-tree/bst.ts

@@ -391,7 +391,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
 
    * @remarks Time O(1) Space O(1)
    */
-  protected _comparator: Comparator<K>;
+  protected readonly _comparator: Comparator<K>;
 
   /**
    * Gets the comparator function used by the tree.

package/src/data-structures/binary-tree/tree-map.ts

@@ -436,4 +436,20 @@ export class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[K, V | u
 
     return out;
   }
+
+  /**
+   * Creates a shallow clone of this map.
+   * @remarks Time O(n log n), Space O(n)
+   * @example
+   * const original = new TreeMap([['a', 1], ['b', 2]]);
+   * const copy = original.clone();
+   * copy.set('c', 3);
+   * original.has('c'); // false (original unchanged)
+   */
+  clone(): TreeMap<K, V> {
+    return new TreeMap<K, V>(this, {
+      comparator: this.#isDefaultComparator ? undefined : this.#userComparator,
+      isMapMode: this.#core.isMapMode
+    });
+  }
 }

package/src/data-structures/binary-tree/tree-multi-set.ts

@@ -247,7 +247,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
    * @remarks Time O(1), Space O(1)
    */
   get comparator(): Comparator<K> {
-    return (this.#core as any)._comparator;
+    return this.#core.comparator;
   }
 
   // ━━━ clear ━━━
@@ -398,7 +398,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
   filter(predicate: (key: K, count: number) => boolean): TreeMultiSet<K> {
     const result = new TreeMultiSet<K>([], {
       comparator: this.#isDefaultComparator ? undefined : this.comparator,
-      isMapMode: (this.#core as any)._isMapMode
+      isMapMode: this.#core.isMapMode
     });
     for (const [k, c] of this.entries()) {
       if (predicate(k, c)) {
@@ -443,7 +443,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
   ): TreeMultiSet<K2> {
     const result = new TreeMultiSet<K2>([], {
       comparator: options?.comparator,
-      isMapMode: (this.#core as any)._isMapMode
+      isMapMode: this.#core.isMapMode
     });
     for (const [k, c] of this.entries()) {
       const [newKey, newCount] = mapper(k, c);
@@ -464,7 +464,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
   clone(): TreeMultiSet<K> {
     const result = new TreeMultiSet<K>([], {
       comparator: this.#isDefaultComparator ? undefined : this.comparator,
-      isMapMode: (this.#core as any)._isMapMode
+      isMapMode: this.#core.isMapMode
     });
     for (const [k, c] of this.entries()) {
       result.add(k, c);
@@ -486,7 +486,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
     callback?: C
   ): (C extends undefined ? K : ReturnType<C>)[] {
     const cb = callback ?? ((k: K) => k);
-    return this.#core.rangeSearch(range, node => cb(node.key)) as any;
+    return this.#core.rangeSearch(range, node => cb(node.key));
   }
 
   /**

package/src/data-structures/binary-tree/tree-set.ts

@@ -404,4 +404,20 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
     return out;
   }
+
+  /**
+   * Creates a shallow clone of this set.
+   * @remarks Time O(n log n), Space O(n)
+   * @example
+   * const original = new TreeSet([1, 2, 3]);
+   * const copy = original.clone();
+   * copy.add(4);
+   * original.has(4); // false (original unchanged)
+   */
+  clone(): TreeSet<K> {
+    return new TreeSet<K>(this, {
+      comparator: this.#isDefaultComparator ? undefined : this.#userComparator,
+      isMapMode: this.#core.isMapMode
+    });
+  }
 }

package/src/data-structures/graph/abstract-graph.ts

@@ -65,7 +65,7 @@ export abstract class AbstractGraph<
    */
   constructor(options?: Partial<Record<string, unknown>>) {
     super();
-    const graph = (options as any)?.graph as GraphOptions<V> | undefined;
+    const graph = (options as { graph?: GraphOptions<V> })?.graph;
     this._options = { defaultEdgeWeight: 1, ...(graph ?? {}) };
   }
 
@@ -984,11 +984,12 @@ export abstract class AbstractGraph<
    * @remarks Time O(1), Space O(1)
    */
   protected _createInstance(_options?: Partial<Record<string, unknown>>): this {
-    const Ctor: any = (this as any).constructor;
-    const instance: this = new Ctor();
-    const graph = (_options as any)?.graph as GraphOptions<V> | undefined;
-    if (graph) (instance as any)._options = { ...(instance as any)._options, ...graph };
-    else (instance as any)._options = { ...(instance as any)._options, ...(this as any)._options };
+    const Ctor = this.constructor as new () => this;
+    const instance = new Ctor();
+    const graph = (_options as { graph?: GraphOptions<V> })?.graph;
+    // Use bracket notation for protected field access on dynamically created instance
+    if (graph) instance['_options'] = { ...instance['_options'], ...graph };
+    else instance['_options'] = { ...instance['_options'], ...this._options };
     return instance;
   }
 
@@ -1009,28 +1010,27 @@ export abstract class AbstractGraph<
     // 1) Add vertices
     if (iter) {
       for (const [k, v] of iter) {
-        (g as any).addVertex(k as VertexKey, v as V | undefined);
+        g.addVertex(k as VertexKey, v as V | undefined);
       }
     } else {
       for (const [k, v] of this) {
-        (g as any).addVertex(k as VertexKey, v as V | undefined);
+        g.addVertex(k as VertexKey, v as V | undefined);
       }
     }
     // 2) Add edges whose endpoints exist in the new graph
     const edges = this.edgeSet();
-    for (const e of edges as any[]) {
-      const ends = this.getEndsOfEdge(e as any) as unknown as [any, any] | undefined;
+    for (const e of edges) {
+      const ends = this.getEndsOfEdge(e);
       if (!ends) continue;
       const [va, vb] = ends;
-      const ka = (va as any).key as VertexKey;
-      const kb = (vb as any).key as VertexKey;
-      const hasA = (g as any).hasVertex ? (g as any).hasVertex(ka) : false;
-      const hasB = (g as any).hasVertex ? (g as any).hasVertex(kb) : false;
+      const ka = va.key;
+      const kb = vb.key;
+      // Defensive check for edge cases where hasVertex may be overridden/undefined
+      const hasA = typeof g.hasVertex === 'function' ? g.hasVertex(ka) : false;
+      const hasB = typeof g.hasVertex === 'function' ? g.hasVertex(kb) : false;
       if (hasA && hasB) {
-        const w = (e as any).weight;
-        const val = (e as any).value;
-        const newEdge = (g as any).createEdge(ka, kb, w, val);
-        (g as any)._addEdge(newEdge);
+        const newEdge = g.createEdge(ka, kb, e.weight, e.value);
+        (g as this & { _addEdge(edge: EO): boolean })._addEdge(newEdge);
       }
     }
     return g;

package/src/data-structures/graph/directed-graph.ts

@@ -207,8 +207,8 @@ export class DirectedGraph<
    * @returns DirectedGraph with all keys added.
    * @remarks Time O(V), Space O(V)
    */
-  static fromKeys<K extends VertexKey>(keys: Iterable<K>): DirectedGraph<K, any, DirectedVertex<K>, DirectedEdge<any>> {
-    const g: DirectedGraph<K, any, DirectedVertex<K>, DirectedEdge<any>> = new DirectedGraph<K, any>({
+  static fromKeys<K extends VertexKey>(keys: Iterable<K>): DirectedGraph<K, undefined, DirectedVertex<K>, DirectedEdge<undefined>> {
+    const g: DirectedGraph<K, undefined, DirectedVertex<K>, DirectedEdge<undefined>> = new DirectedGraph<K, undefined>({
       vertexValueInitializer: (k: VertexKey) => k as K
     });
     for (const k of keys) g.addVertex(k);
@@ -224,8 +224,8 @@ export class DirectedGraph<
    */
   static fromEntries<V>(
     entries: Iterable<[VertexKey, V]>
-  ): DirectedGraph<V, any, DirectedVertex<V>, DirectedEdge<any>> {
-    const g: DirectedGraph<V, any, DirectedVertex<V>, DirectedEdge<any>> = new DirectedGraph<V, any>();
+  ): DirectedGraph<V, undefined, DirectedVertex<V>, DirectedEdge<undefined>> {
+    const g: DirectedGraph<V, undefined, DirectedVertex<V>, DirectedEdge<undefined>> = new DirectedGraph<V, undefined>();
     for (const [k, v] of entries) g.addVertex(k, v);
     return g;
   }