data-structure-typed 2.6.0 → 2.6.1

package/src/data-structures/heap/heap.ts

@@ -5,7 +5,6 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-
 import type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '../../types';
 import { IterableElementBase } from '../base';
 import { ERR, raise } from '../../common';
@@ -157,15 +156,12 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param [options] - Options such as comparator and toElementFn.
    * @returns New Heap instance.
    */
-
   constructor(elements: Iterable<E | R> = [], options?: HeapOptions<E, R>) {
     super(options);
-
     if (options) {
       const { comparator } = options;
       if (comparator) this._comparator = comparator;
     }
-
     this.addMany(elements as Iterable<E | R>);
   }
 
@@ -176,7 +172,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(1), Space O(1)
    * @returns Internal elements array.
    */
-
   get elements(): E[] {
     return this._elements;
   }
@@ -185,59 +180,16 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Get the number of elements.
    * @remarks Time O(1), Space O(1)
    * @returns Heap size.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Track heap capacity
- *  const heap = new Heap<number>();
- *     console.log(heap.size); // 0;
- *     heap.add(10);
- *     heap.add(20);
- *     console.log(heap.size); // 2;
- *     heap.poll();
- *     console.log(heap.size); // 1;
+   * @example
+   * // Track heap capacity
+   *  const heap = new Heap<number>();
+   *     console.log(heap.size); // 0;
+   *     heap.add(10);
+   *     heap.add(20);
+   *     console.log(heap.size); // 2;
+   *     heap.poll();
+   *     console.log(heap.size); // 1;
    */
-
   get size(): number {
     return this.elements.length;
   }
@@ -247,11 +199,19 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(1), Space O(1)
    * @returns Last element or undefined.
    */
-
   get leaf(): E | undefined {
     return this.elements[this.size - 1] ?? undefined;
   }
 
+  /**
+   * Get the comparator used to order elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns Comparator function.
+   */
+  get comparator() {
+    return this._comparator;
+  }
+
   /**
    * Create a heap of the same class from an iterable.
    * @remarks Time O(N), Space O(N)
@@ -262,7 +222,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param [options] - Heap options including comparator.
    * @returns A new heap instance of this class.
    */
-
   static from<T, R = any, S extends Heap<T, R> = Heap<T, R>>(
     this: new (elements?: Iterable<T | R>, options?: HeapOptions<T, R>) => S,
     elements?: Iterable<T | R>,
@@ -280,7 +239,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param options - Heap options including comparator.
    * @returns A new Heap built from elements.
    */
-
   static heapify<EE = any, RR = any>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
     return new Heap<EE, RR>(elements, options);
   }
@@ -290,65 +248,22 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(log N) amortized, Space O(1)
    * @param element - Element to insert.
    * @returns True.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // basic Heap creation and add operation
- *  // Create a min heap (default)
- *     const minHeap = new Heap([5, 3, 7, 1, 9, 2]);
- *
- *     // Verify size
- *     console.log(minHeap.size); // 6;
- *
- *     // Add new element
- *     minHeap.add(4);
- *     console.log(minHeap.size); // 7;
- *
- *     // Min heap property: smallest element at root
- *     const min = minHeap.peek();
- *     console.log(min); // 1;
+   * @example
+   * // basic Heap creation and add operation
+   *  // Create a min heap (default)
+   *     const minHeap = new Heap([5, 3, 7, 1, 9, 2]);
+   *
+   *     // Verify size
+   *     console.log(minHeap.size); // 6;
+   *
+   *     // Add new element
+   *     minHeap.add(4);
+   *     console.log(minHeap.size); // 7;
+   *
+   *     // Min heap property: smallest element at root
+   *     const min = minHeap.peek();
+   *     console.log(min); // 1;
    */
-
   add(element: E): boolean {
     this._elements.push(element);
     return this._bubbleUp(this.elements.length - 1);
@@ -359,53 +274,13 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(N log N), Space O(1)
    * @param elements - Iterable of elements or raw values.
    * @returns Array of per-element success flags.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Add multiple elements
- *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
- *     heap.addMany([5, 3, 7, 1]);
- *     console.log(heap.peek()); // 1;
- *     console.log(heap.size); // 4;
+   * @example
+   * // Add multiple elements
+   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
+   *     heap.addMany([5, 3, 7, 1]);
+   *     console.log(heap.peek()); // 1;
+   *     console.log(heap.size); // 4;
    */
-
   addMany(elements: Iterable<E | R>): boolean[] {
     const flags: boolean[] = [];
     for (const el of elements) {
@@ -424,101 +299,59 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Remove and return the top element.
    * @remarks Time O(log N), Space O(1)
    * @returns Top element or undefined.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Heap with custom comparator (MaxHeap behavior)
- *  interface Task {
- *       id: number;
- *       priority: number;
- *       name: string;
- *     }
- *
- *     // Custom comparator for max heap behavior (higher priority first)
- *     const tasks: Task[] = [
- *       { id: 1, priority: 5, name: 'Email' },
- *       { id: 2, priority: 3, name: 'Chat' },
- *       { id: 3, priority: 8, name: 'Alert' }
- *     ];
- *
- *     const maxHeap = new Heap(tasks, {
- *       comparator: (a: Task, b: Task) => b.priority - a.priority
- *     });
- *
- *     console.log(maxHeap.size); // 3;
- *
- *     // Peek returns highest priority task
- *     const topTask = maxHeap.peek();
- *     console.log(topTask?.priority); // 8;
- *     console.log(topTask?.name); // 'Alert';
+   * @example
+   * // Heap with custom comparator (MaxHeap behavior)
+   *  interface Task {
+   *       id: number;
+   *       priority: number;
+   *       name: string;
+   *     }
+   *
+   *     // Custom comparator for max heap behavior (higher priority first)
+   *     const tasks: Task[] = [
+   *       { id: 1, priority: 5, name: 'Email' },
+   *       { id: 2, priority: 3, name: 'Chat' },
+   *       { id: 3, priority: 8, name: 'Alert' }
+   *     ];
+   *
+   *     const maxHeap = new Heap(tasks, {
+   *       comparator: (a: Task, b: Task) => b.priority - a.priority
+   *     });
+   *
+   *     console.log(maxHeap.size); // 3;
+   *
+   *     // Peek returns highest priority task
+   *     const topTask = maxHeap.peek();
+   *     console.log(topTask?.priority); // 8;
+   *     console.log(topTask?.name); // 'Alert';
    */
-
   /**
    * @deprecated Use `pop` instead. Will be removed in a future major version.
-   
-   
-   
-    * @example
- * // Heap with custom comparator (MaxHeap behavior)
- *  interface Task {
- *       id: number;
- *       priority: number;
- *       name: string;
- *     }
- *
- *     // Custom comparator for max heap behavior (higher priority first)
- *     const tasks: Task[] = [
- *       { id: 1, priority: 5, name: 'Email' },
- *       { id: 2, priority: 3, name: 'Chat' },
- *       { id: 3, priority: 8, name: 'Alert' }
- *     ];
- *
- *     const maxHeap = new Heap(tasks, {
- *       comparator: (a: Task, b: Task) => b.priority - a.priority
- *     });
- *
- *     console.log(maxHeap.size); // 3;
- *
- *     // Peek returns highest priority task
- *     const topTask = maxHeap.peek();
- *     console.log(topTask?.priority); // 8;
- *     console.log(topTask?.name); // 'Alert';
+   * @example
+   * // Heap with custom comparator (MaxHeap behavior)
+   *  interface Task {
+   *       id: number;
+   *       priority: number;
+   *       name: string;
+   *     }
+   *
+   *     // Custom comparator for max heap behavior (higher priority first)
+   *     const tasks: Task[] = [
+   *       { id: 1, priority: 5, name: 'Email' },
+   *       { id: 2, priority: 3, name: 'Chat' },
+   *       { id: 3, priority: 8, name: 'Alert' }
+   *     ];
+   *
+   *     const maxHeap = new Heap(tasks, {
+   *       comparator: (a: Task, b: Task) => b.priority - a.priority
+   *     });
+   *
+   *     console.log(maxHeap.size); // 3;
+   *
+   *     // Peek returns highest priority task
+   *     const topTask = maxHeap.peek();
+   *     console.log(topTask?.priority); // 8;
+   *     console.log(topTask?.name); // 'Alert';
    */
   poll(): E | undefined {
     return this.pop();
@@ -544,109 +377,66 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Get the current top element without removing it.
    * @remarks Time O(1), Space O(1)
    * @returns Top element or undefined.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Heap for event processing with priority
- *  interface Event {
- *       id: number;
- *       type: 'critical' | 'warning' | 'info';
- *       timestamp: number;
- *       message: string;
- *     }
- *
- *     // Custom priority: critical > warning > info
- *     const priorityMap = { critical: 3, warning: 2, info: 1 };
- *
- *     const eventHeap = new Heap<Event>([], {
- *       comparator: (a: Event, b: Event) => {
- *         const priorityA = priorityMap[a.type];
- *         const priorityB = priorityMap[b.type];
- *         return priorityB - priorityA; // Higher priority first
- *       }
- *     });
- *
- *     // Add events in random order
- *     eventHeap.add({ id: 1, type: 'info', timestamp: 100, message: 'User logged in' });
- *     eventHeap.add({ id: 2, type: 'critical', timestamp: 101, message: 'Server down' });
- *     eventHeap.add({ id: 3, type: 'warning', timestamp: 102, message: 'High memory' });
- *     eventHeap.add({ id: 4, type: 'info', timestamp: 103, message: 'Cache cleared' });
- *     eventHeap.add({ id: 5, type: 'critical', timestamp: 104, message: 'Database error' });
- *
- *     console.log(eventHeap.size); // 5;
- *
- *     // Process events by priority (critical first)
- *     const processedOrder: Event[] = [];
- *     while (eventHeap.size > 0) {
- *       const event = eventHeap.poll();
- *       if (event) {
- *         processedOrder.push(event);
- *       }
- *     }
- *
- *     // Verify critical events came first
- *     console.log(processedOrder[0].type); // 'critical';
- *     console.log(processedOrder[1].type); // 'critical';
- *     console.log(processedOrder[2].type); // 'warning';
- *     console.log(processedOrder[3].type); // 'info';
- *     console.log(processedOrder[4].type); // 'info';
- *
- *     // Verify O(log n) operations
- *     const newHeap = new Heap<number>([5, 3, 7, 1]);
- *
- *     // Add - O(log n)
- *     newHeap.add(2);
- *     console.log(newHeap.size); // 5;
- *
- *     // Poll - O(log n)
- *     const removed = newHeap.poll();
- *     console.log(removed); // 1;
- *
- *     // Peek - O(1)
- *     const top = newHeap.peek();
- *     console.log(top); // 2;
+   * @example
+   * // Heap for event processing with priority
+   *  interface Event {
+   *       id: number;
+   *       type: 'critical' | 'warning' | 'info';
+   *       timestamp: number;
+   *       message: string;
+   *     }
+   *
+   *     // Custom priority: critical > warning > info
+   *     const priorityMap = { critical: 3, warning: 2, info: 1 };
+   *
+   *     const eventHeap = new Heap<Event>([], {
+   *       comparator: (a: Event, b: Event) => {
+   *         const priorityA = priorityMap[a.type];
+   *         const priorityB = priorityMap[b.type];
+   *         return priorityB - priorityA; // Higher priority first
+   *       }
+   *     });
+   *
+   *     // Add events in random order
+   *     eventHeap.add({ id: 1, type: 'info', timestamp: 100, message: 'User logged in' });
+   *     eventHeap.add({ id: 2, type: 'critical', timestamp: 101, message: 'Server down' });
+   *     eventHeap.add({ id: 3, type: 'warning', timestamp: 102, message: 'High memory' });
+   *     eventHeap.add({ id: 4, type: 'info', timestamp: 103, message: 'Cache cleared' });
+   *     eventHeap.add({ id: 5, type: 'critical', timestamp: 104, message: 'Database error' });
+   *
+   *     console.log(eventHeap.size); // 5;
+   *
+   *     // Process events by priority (critical first)
+   *     const processedOrder: Event[] = [];
+   *     while (eventHeap.size > 0) {
+   *       const event = eventHeap.poll();
+   *       if (event) {
+   *         processedOrder.push(event);
+   *       }
+   *     }
+   *
+   *     // Verify critical events came first
+   *     console.log(processedOrder[0].type); // 'critical';
+   *     console.log(processedOrder[1].type); // 'critical';
+   *     console.log(processedOrder[2].type); // 'warning';
+   *     console.log(processedOrder[3].type); // 'info';
+   *     console.log(processedOrder[4].type); // 'info';
+   *
+   *     // Verify O(log n) operations
+   *     const newHeap = new Heap<number>([5, 3, 7, 1]);
+   *
+   *     // Add - O(log n)
+   *     newHeap.add(2);
+   *     console.log(newHeap.size); // 5;
+   *
+   *     // Poll - O(log n)
+   *     const removed = newHeap.poll();
+   *     console.log(removed); // 1;
+   *
+   *     // Peek - O(1)
+   *     const top = newHeap.peek();
+   *     console.log(top); // 2;
    */
-
   peek(): E | undefined {
     return this.elements[0];
   }
@@ -655,54 +445,13 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Check whether the heap is empty.
    * @remarks Time O(1), Space O(1)
    * @returns True if size is 0.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Check if heap is empty
- *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
- *     console.log(heap.isEmpty()); // true;
- *     heap.add(1);
- *     console.log(heap.isEmpty()); // false;
+   * @example
+   * // Check if heap is empty
+   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
+   *     console.log(heap.isEmpty()); // true;
+   *     heap.add(1);
+   *     console.log(heap.isEmpty()); // false;
    */
-
   isEmpty(): boolean {
     return this.size === 0;
   }
@@ -711,104 +460,27 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Remove all elements.
    * @remarks Time O(1), Space O(1)
    * @returns void
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove all elements
- *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
- *     heap.clear();
- *     console.log(heap.isEmpty()); // true;
+   * @example
+   * // Remove all elements
+   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
+   *     heap.clear();
+   *     console.log(heap.isEmpty()); // true;
    */
-
   clear(): void {
     this._elements = [];
   }
 
-
-
   /**
    * Check if an equal element exists in the heap.
    * @remarks Time O(N), Space O(1)
    * @param element - Element to search for.
    * @returns True if found.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Check element existence
- *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
- *     console.log(heap.has(1)); // true;
- *     console.log(heap.has(99)); // false;
+   * @example
+   * // Check element existence
+   *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
+   *     console.log(heap.has(1)); // true;
+   *     console.log(heap.has(99)); // false;
    */
-
   override has(element: E): boolean {
     for (const el of this.elements) if (this._equals(el, element)) return true;
     return false;
@@ -819,52 +491,12 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(N), Space O(1)
    * @param element - Element to delete.
    * @returns True if an element was removed.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove specific element
- *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
- *     heap.delete(4);
- *     console.log(heap.toArray().includes(4)); // false;
+   * @example
+   * // Remove specific element
+   *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
+   *     heap.delete(4);
+   *     console.log(heap.toArray().includes(4)); // false;
    */
-
   delete(element: E): boolean {
     let index = -1;
     for (let i = 0; i < this.elements.length; i++) {
@@ -926,7 +558,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param equals - Equality predicate (a, b) → boolean.
    * @returns This heap.
    */
-
   setEquality(equals: (a: E, b: E) => boolean): this {
     this._equals = equals;
     return this;
@@ -937,46 +568,12 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(N), Space O(H)
    * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.
    * @returns Array of visited elements.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Depth-first traversal
- *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
- *     const result = heap.dfs('IN');
- *     console.log(result.length); // 3;
+   * @example
+   * // Depth-first traversal
+   *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
+   *     const result = heap.dfs('IN');
+   *     console.log(result.length); // 3;
    */
-
   dfs(order: DFSOrderPattern = 'PRE'): E[] {
     const result: E[] = [];
     const _dfs = (index: number) => {
@@ -1007,7 +604,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @remarks Time O(N), Space O(1)
    * @returns Array of per-node results from fixing steps.
    */
-
   fix(): boolean[] {
     const results: boolean[] = [];
     for (let i = Math.floor(this.size / 2) - 1; i >= 0; i--) {
@@ -1020,55 +616,12 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Return all elements in ascending order by repeatedly polling.
    * @remarks Time O(N log N), Space O(N)
    * @returns Sorted array of elements.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Sort elements using heap
- *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
- *     const sorted = heap.sort();
- *     console.log(sorted); // [1, 2, 3, 4, 5];
+   * @example
+   * // Sort elements using heap
+   *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
+   *     const sorted = heap.sort();
+   *     console.log(sorted); // [1, 2, 3, 4, 5];
    */
-
   sort(): E[] {
     const visited: E[] = [];
     const cloned = this._createInstance();
@@ -1084,55 +637,14 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * Deep clone this heap.
    * @remarks Time O(N), Space O(N)
    * @returns A new heap with the same elements.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Create independent copy
- *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
- *     const copy = heap.clone();
- *     copy.poll();
- *     console.log(heap.size); // 3;
- *     console.log(copy.size); // 2;
+   * @example
+   * // Create independent copy
+   *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
+   *     const copy = heap.clone();
+   *     copy.poll();
+   *     console.log(heap.size); // 3;
+   *     console.log(copy.size); // 2;
    */
-
   clone(): this {
     const next = this._createInstance();
     for (const x of this.elements) next.add(x);
@@ -1145,53 +657,12 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param callback - Predicate (element, index, heap) → boolean to keep element.
    * @param [thisArg] - Value for `this` inside the callback.
    * @returns A new heap with the kept elements.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Filter elements
- *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
- *     const evens = heap.filter(x => x % 2 === 0);
- *     console.log(evens.size); // 2;
+   * @example
+   * // Filter elements
+   *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
+   *     const evens = heap.filter(x => x % 2 === 0);
+   *     console.log(evens.size); // 2;
    */
-
   filter(callback: ElementCallback<E, R, boolean>, thisArg?: unknown): this {
     const out = this._createInstance();
     let i = 0;
@@ -1214,52 +685,12 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param options - Options for the output heap, including comparator for EM.
    * @param [thisArg] - Value for `this` inside the callback.
    * @returns A new heap with mapped elements.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Transform elements
- *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
- *     const doubled = heap.map(x => x * 2, { comparator: (a, b) => a - b });
- *     console.log(doubled.peek()); // 2;
+   * @example
+   * // Transform elements
+   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
+   *     const doubled = heap.map(x => x * 2, { comparator: (a, b) => a - b });
+   *     console.log(doubled.peek()); // 2;
    */
-
   map<EM, RM>(
     callback: ElementCallback<E, R, EM>,
     options: HeapOptions<EM, RM> & { comparator: Comparator<EM> },
@@ -1283,7 +714,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param [thisArg] - Value for `this` inside the callback.
    * @returns A new heap with mapped elements.
    */
-
   mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this {
     const out = this._createInstance();
     let i = 0;
@@ -1305,16 +735,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
 
   protected readonly _comparator: Comparator<E> = this._DEFAULT_COMPARATOR;
 
-  /**
-   * Get the comparator used to order elements.
-   * @remarks Time O(1), Space O(1)
-   * @returns Comparator function.
-   */
-
-  get comparator() {
-    return this._comparator;
-  }
-
   protected *_getIterator(): IterableIterator<E> {
     for (const element of this.elements) yield element;
   }
@@ -1356,12 +776,8 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param [options] - Options to override comparator or toElementFn.
    * @returns A like-kind empty heap instance.
    */
-
   protected _createInstance(options?: HeapOptions<E, R>): this {
-    const Ctor = this.constructor as new (
-      elements?: Iterable<E> | Iterable<R>,
-      options?: HeapOptions<E, R>
-    ) => this;
+    const Ctor = this.constructor as new (elements?: Iterable<E> | Iterable<R>, options?: HeapOptions<E, R>) => this;
     return new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...(options ?? {}) });
   }
 
@@ -1374,7 +790,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param [options] - Options forwarded to the constructor.
    * @returns A like-kind heap instance.
    */
-
   protected _createLike<EM, RM>(
     elements: Iterable<EM> | Iterable<RM> = [],
     options?: HeapOptions<EM, RM>
@@ -1394,7 +809,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    * @param [options] - Options forwarded to the constructor.
    * @returns An empty like-kind heap instance.
    */
-
   protected _spawnLike<EM, RM>(options?: HeapOptions<EM, RM>): Heap<EM, RM> {
     return this._createLike<EM, RM>([], options);
   }
@@ -1428,13 +842,14 @@ export class FibonacciHeapNode<E> {
  * @example examples will be generated by unit test
  */
 export class FibonacciHeap<E> {
+  protected readonly _comparator: Comparator<E>;
+
   /**
    * Create a FibonacciHeap.
    * @remarks Time O(1), Space O(1)
    * @param [comparator] - Comparator to order elements (min-heap by default).
    * @returns New FibonacciHeap instance.
    */
-
   constructor(comparator?: Comparator<E>) {
     this.clear();
     this._comparator = comparator || this._defaultComparator;
@@ -1448,12 +863,12 @@ export class FibonacciHeap<E> {
    * @remarks Time O(1), Space O(1)
    * @returns Root node or undefined.
    */
-
   get root(): FibonacciHeapNode<E> | undefined {
     return this._root;
   }
 
   protected _size = 0;
+
   get size(): number {
     return this._size;
   }
@@ -1465,13 +880,10 @@ export class FibonacciHeap<E> {
    * @remarks Time O(1), Space O(1)
    * @returns Min node or undefined.
    */
-
   get min(): FibonacciHeapNode<E> | undefined {
     return this._min;
   }
 
-  protected readonly _comparator: Comparator<E>;
-
   get comparator(): Comparator<E> {
     return this._comparator;
   }
@@ -1493,7 +905,6 @@ export class FibonacciHeap<E> {
    * @param element - Element to insert.
    * @returns True when the element is added.
    */
-
   push(element: E): boolean {
     const node = this.createNode(element);
     node.left = node;
@@ -1514,7 +925,6 @@ export class FibonacciHeap<E> {
    * @param [head] - Start node of the circular list.
    * @returns Array of nodes from the list.
    */
-
   consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[] {
     const elements: FibonacciHeapNode<E>[] = [];
     if (!head) return elements;
@@ -1536,7 +946,6 @@ export class FibonacciHeap<E> {
    * @param node - Child node to insert.
    * @returns void
    */
-
   mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void {
     if (!parent.child) parent.child = node;
     else {
@@ -1556,7 +965,6 @@ export class FibonacciHeap<E> {
    * @remarks Time O(log N) amortized, Space O(1)
    * @returns Minimum element or undefined.
    */
-
   pop(): E | undefined {
     if (this._size === 0) return undefined;
     const z = this.min!;
@@ -1585,7 +993,6 @@ export class FibonacciHeap<E> {
    * @param heapToMerge - Another FibonacciHeap to meld into this one.
    * @returns void
    */
-
   merge(heapToMerge: FibonacciHeap<E>): void {
     if (heapToMerge.size === 0) return;
     if (this.root && heapToMerge.root) {
@@ -1653,7 +1060,6 @@ export class FibonacciHeap<E> {
       y: FibonacciHeapNode<E> | undefined,
       d: number,
       t: FibonacciHeapNode<E> | undefined;
-
     for (const node of elements) {
       x = node;
       d = x.degree;
@@ -1670,7 +1076,6 @@ export class FibonacciHeap<E> {
       }
       A[d] = x;
     }
-
     for (let i = 0; i < A.length; i++) {
       if (A[i] && (!this.min || this.comparator(A[i]!.element, this.min.element) <= 0)) this._min = A[i]!;
     }