max-heap-typed 2.1.1 → 2.2.0

package/dist/cjs/index.cjs

@@ -0,0 +1,1001 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/data-structures/base/iterable-element-base.ts
+var IterableElementBase = class {
+  static {
+    __name(this, "IterableElementBase");
+  }
+  /**
+   * Create a new iterable base.
+   *
+   * @param options Optional behavior overrides. When provided, a `toElementFn`
+   * is used to convert a raw element (`R`) into a public element (`E`).
+   *
+   * @remarks
+   * Time O(1), Space O(1).
+   */
+  constructor(options) {
+    if (options) {
+      const { toElementFn } = options;
+      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
+      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+    }
+  }
+  /**
+   * The converter used to transform a raw element (`R`) into a public element (`E`).
+   *
+   * @remarks
+   * Time O(1), Space O(1).
+   */
+  _toElementFn;
+  /**
+   * Exposes the current `toElementFn`, if configured.
+   *
+   * @returns The converter function or `undefined` when not set.
+   * @remarks
+   * Time O(1), Space O(1).
+   */
+  get toElementFn() {
+    return this._toElementFn;
+  }
+  /**
+   * Returns an iterator over the structure's elements.
+   *
+   * @param args Optional iterator arguments forwarded to the internal iterator.
+   * @returns An `IterableIterator<E>` that yields the elements in traversal order.
+   *
+   * @remarks
+   * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.
+   */
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  /**
+   * Returns an iterator over the values (alias of the default iterator).
+   *
+   * @returns An `IterableIterator<E>` over all elements.
+   * @remarks
+   * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).
+   */
+  *values() {
+    for (const item of this) yield item;
+  }
+  /**
+   * Tests whether all elements satisfy the predicate.
+   *
+   * @template TReturn
+   * @param predicate Function invoked for each element with signature `(value, index, self)`.
+   * @param thisArg Optional `this` binding for the predicate.
+   * @returns `true` if every element passes; otherwise `false`.
+   *
+   * @remarks
+   * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).
+   */
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (!predicate(item, index++, this)) return false;
+      } else {
+        const fn = predicate;
+        if (!fn.call(thisArg, item, index++, this)) return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Tests whether at least one element satisfies the predicate.
+   *
+   * @param predicate Function invoked for each element with signature `(value, index, self)`.
+   * @param thisArg Optional `this` binding for the predicate.
+   * @returns `true` if any element passes; otherwise `false`.
+   *
+   * @remarks
+   * Time O(n) in the worst case; may exit early on first success. Space O(1).
+   */
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return true;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Invokes a callback for each element in iteration order.
+   *
+   * @param callbackfn Function invoked per element with signature `(value, index, self)`.
+   * @param thisArg Optional `this` binding for the callback.
+   * @returns `void`.
+   *
+   * @remarks
+   * Time O(n), Space O(1).
+   */
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        callbackfn(item, index++, this);
+      } else {
+        const fn = callbackfn;
+        fn.call(thisArg, item, index++, this);
+      }
+    }
+  }
+  // Implementation signature
+  find(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return item;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return item;
+      }
+    }
+    return;
+  }
+  /**
+   * Checks whether a strictly-equal element exists in the structure.
+   *
+   * @param element The element to test with `===` equality.
+   * @returns `true` if an equal element is found; otherwise `false`.
+   *
+   * @remarks
+   * Time O(n) in the worst case. Space O(1).
+   */
+  has(element) {
+    for (const ele of this) if (ele === element) return true;
+    return false;
+  }
+  /**
+   * Reduces all elements to a single accumulated value.
+   *
+   * @overload
+   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`. The first element is used as the initial accumulator.
+   * @returns The final accumulated value typed as `E`.
+   *
+   * @overload
+   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`.
+   * @param initialValue The initial accumulator value of type `E`.
+   * @returns The final accumulated value typed as `E`.
+   *
+   * @overload
+   * @template U The accumulator type when it differs from `E`.
+   * @param callbackfn Reducer of signature `(acc: U, value, index, self) => U`.
+   * @param initialValue The initial accumulator value of type `U`.
+   * @returns The final accumulated value typed as `U`.
+   *
+   * @remarks
+   * Time O(n), Space O(1). Throws if called on an empty structure without `initialValue`.
+   */
+  reduce(callbackfn, initialValue) {
+    let index = 0;
+    const iter = this[Symbol.iterator]();
+    let acc;
+    if (arguments.length >= 2) {
+      acc = initialValue;
+    } else {
+      const first = iter.next();
+      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+      acc = first.value;
+      index = 1;
+    }
+    for (const value of iter) {
+      acc = callbackfn(acc, value, index++, this);
+    }
+    return acc;
+  }
+  /**
+   * Materializes the elements into a new array.
+   *
+   * @returns A shallow array copy of the iteration order.
+   * @remarks
+   * Time O(n), Space O(n).
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Returns a representation of the structure suitable for quick visualization.
+   * Defaults to an array of elements; subclasses may override to provide richer visuals.
+   *
+   * @returns A visual representation (array by default).
+   * @remarks
+   * Time O(n), Space O(n).
+   */
+  toVisual() {
+    return [...this];
+  }
+  /**
+   * Prints `toVisual()` to the console. Intended for quick debugging.
+   *
+   * @returns `void`.
+   * @remarks
+   * Time O(n) due to materialization, Space O(n) for the intermediate representation.
+   */
+  print() {
+    console.log(this.toVisual());
+  }
+};
+
+// src/data-structures/heap/heap.ts
+var Heap = class _Heap extends IterableElementBase {
+  static {
+    __name(this, "Heap");
+  }
+  _equals = Object.is;
+  /**
+   * Create a Heap and optionally bulk-insert elements.
+   * @remarks Time O(N), Space O(N)
+   * @param [elements] - Iterable of elements (or raw values if toElementFn is set).
+   * @param [options] - Options such as comparator and toElementFn.
+   * @returns New Heap instance.
+   */
+  constructor(elements = [], options) {
+    super(options);
+    if (options) {
+      const { comparator } = options;
+      if (comparator) this._comparator = comparator;
+    }
+    this.addMany(elements);
+  }
+  _elements = [];
+  /**
+   * Get the backing array of the heap.
+   * @remarks Time O(1), Space O(1)
+   * @returns Internal elements array.
+   */
+  get elements() {
+    return this._elements;
+  }
+  /**
+   * Get the number of elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns Heap size.
+   */
+  get size() {
+    return this.elements.length;
+  }
+  /**
+   * Get the last leaf element.
+   * @remarks Time O(1), Space O(1)
+   * @returns Last element or undefined.
+   */
+  get leaf() {
+    return this.elements[this.size - 1] ?? void 0;
+  }
+  /**
+   * Create a heap of the same class from an iterable.
+   * @remarks Time O(N), Space O(N)
+   * @template T
+   * @template R
+   * @template S
+   * @param [elements] - Iterable of elements or raw records.
+   * @param [options] - Heap options including comparator.
+   * @returns A new heap instance of this class.
+   */
+  static from(elements, options) {
+    return new this(elements, options);
+  }
+  /**
+   * Build a Heap from an iterable in linear time given a comparator.
+   * @remarks Time O(N), Space O(N)
+   * @template EE
+   * @template RR
+   * @param elements - Iterable of elements.
+   * @param options - Heap options including comparator.
+   * @returns A new Heap built from elements.
+   */
+  static heapify(elements, options) {
+    return new _Heap(elements, options);
+  }
+  /**
+   * Insert an element.
+   * @remarks Time O(1) amortized, Space O(1)
+   * @param element - Element to insert.
+   * @returns True.
+   */
+  add(element) {
+    this._elements.push(element);
+    return this._bubbleUp(this.elements.length - 1);
+  }
+  /**
+   * Insert many elements from an iterable.
+   * @remarks Time O(N log N), Space O(1)
+   * @param elements - Iterable of elements or raw values.
+   * @returns Array of per-element success flags.
+   */
+  addMany(elements) {
+    const flags = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        const ok = this.add(this.toElementFn(el));
+        flags.push(ok);
+      } else {
+        const ok = this.add(el);
+        flags.push(ok);
+      }
+    }
+    return flags;
+  }
+  /**
+   * Remove and return the top element.
+   * @remarks Time O(log N), Space O(1)
+   * @returns Top element or undefined.
+   */
+  poll() {
+    if (this.elements.length === 0) return;
+    const value = this.elements[0];
+    const last = this.elements.pop();
+    if (this.elements.length) {
+      this.elements[0] = last;
+      this._sinkDown(0, this.elements.length >> 1);
+    }
+    return value;
+  }
+  /**
+   * Get the current top element without removing it.
+   * @remarks Time O(1), Space O(1)
+   * @returns Top element or undefined.
+   */
+  peek() {
+    return this.elements[0];
+  }
+  /**
+   * Check whether the heap is empty.
+   * @remarks Time O(1), Space O(1)
+   * @returns True if size is 0.
+   */
+  isEmpty() {
+    return this.size === 0;
+  }
+  /**
+   * Remove all elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns void
+   */
+  clear() {
+    this._elements = [];
+  }
+  /**
+   * Replace the backing array and rebuild the heap.
+   * @remarks Time O(N), Space O(N)
+   * @param elements - Iterable used to refill the heap.
+   * @returns Array of per-node results from fixing steps.
+   */
+  refill(elements) {
+    this._elements = Array.from(elements);
+    return this.fix();
+  }
+  /**
+   * 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.
+   */
+  has(element) {
+    for (const el of this.elements) if (this._equals(el, element)) return true;
+    return false;
+  }
+  /**
+   * Delete one occurrence of an element.
+   * @remarks Time O(N), Space O(1)
+   * @param element - Element to delete.
+   * @returns True if an element was removed.
+   */
+  delete(element) {
+    let index = -1;
+    for (let i = 0; i < this.elements.length; i++) {
+      if (this._equals(this.elements[i], element)) {
+        index = i;
+        break;
+      }
+    }
+    if (index < 0) return false;
+    if (index === 0) {
+      this.poll();
+    } else if (index === this.elements.length - 1) {
+      this.elements.pop();
+    } else {
+      this.elements.splice(index, 1, this.elements.pop());
+      this._bubbleUp(index);
+      this._sinkDown(index, this.elements.length >> 1);
+    }
+    return true;
+  }
+  /**
+   * Delete the first element that matches a predicate.
+   * @remarks Time O(N), Space O(1)
+   * @param predicate - Function (element, index, heap) → boolean.
+   * @returns True if an element was removed.
+   */
+  deleteBy(predicate) {
+    let idx = -1;
+    for (let i = 0; i < this.elements.length; i++) {
+      if (predicate(this.elements[i], i, this)) {
+        idx = i;
+        break;
+      }
+    }
+    if (idx < 0) return false;
+    if (idx === 0) {
+      this.poll();
+    } else if (idx === this.elements.length - 1) {
+      this.elements.pop();
+    } else {
+      this.elements.splice(idx, 1, this.elements.pop());
+      this._bubbleUp(idx);
+      this._sinkDown(idx, this.elements.length >> 1);
+    }
+    return true;
+  }
+  /**
+   * Set the equality comparator used by has/delete operations.
+   * @remarks Time O(1), Space O(1)
+   * @param equals - Equality predicate (a, b) → boolean.
+   * @returns This heap.
+   */
+  setEquality(equals) {
+    this._equals = equals;
+    return this;
+  }
+  /**
+   * Traverse the binary heap as a complete binary tree and collect elements.
+   * @remarks Time O(N), Space O(H)
+   * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.
+   * @returns Array of visited elements.
+   */
+  dfs(order = "PRE") {
+    const result = [];
+    const _dfs = /* @__PURE__ */ __name((index) => {
+      const left = 2 * index + 1, right = left + 1;
+      if (index < this.size) {
+        if (order === "IN") {
+          _dfs(left);
+          result.push(this.elements[index]);
+          _dfs(right);
+        } else if (order === "PRE") {
+          result.push(this.elements[index]);
+          _dfs(left);
+          _dfs(right);
+        } else if (order === "POST") {
+          _dfs(left);
+          _dfs(right);
+          result.push(this.elements[index]);
+        }
+      }
+    }, "_dfs");
+    _dfs(0);
+    return result;
+  }
+  /**
+   * Restore heap order bottom-up (heapify in-place).
+   * @remarks Time O(N), Space O(1)
+   * @returns Array of per-node results from fixing steps.
+   */
+  fix() {
+    const results = [];
+    for (let i = Math.floor(this.size / 2) - 1; i >= 0; i--) {
+      results.push(this._sinkDown(i, this.elements.length >> 1));
+    }
+    return results;
+  }
+  /**
+   * Return all elements in ascending order by repeatedly polling.
+   * @remarks Time O(N log N), Space O(N)
+   * @returns Sorted array of elements.
+   */
+  sort() {
+    const visited = [];
+    const cloned = this._createInstance();
+    for (const x of this.elements) cloned.add(x);
+    while (!cloned.isEmpty()) {
+      const top = cloned.poll();
+      if (top !== void 0) visited.push(top);
+    }
+    return visited;
+  }
+  /**
+   * Deep clone this heap.
+   * @remarks Time O(N), Space O(N)
+   * @returns A new heap with the same elements.
+   */
+  clone() {
+    const next = this._createInstance();
+    for (const x of this.elements) next.add(x);
+    return next;
+  }
+  /**
+   * Filter elements into a new heap of the same class.
+   * @remarks Time O(N log N), Space O(N)
+   * @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.
+   */
+  filter(callback, thisArg) {
+    const out = this._createInstance();
+    let i = 0;
+    for (const x of this) {
+      if (thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this)) {
+        out.add(x);
+      } else {
+        i++;
+      }
+    }
+    return out;
+  }
+  /**
+   * Map elements into a new heap of possibly different element type.
+   * @remarks Time O(N log N), Space O(N)
+   * @template EM
+   * @template RM
+   * @param callback - Mapping function (element, index, heap) → newElement.
+   * @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.
+   */
+  map(callback, options, thisArg) {
+    const { comparator, toElementFn, ...rest } = options ?? {};
+    if (!comparator) throw new TypeError("Heap.map requires options.comparator for EM");
+    const out = this._createLike([], { ...rest, comparator, toElementFn });
+    let i = 0;
+    for (const x of this) {
+      const v = thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
+      out.add(v);
+    }
+    return out;
+  }
+  /**
+   * Map elements into a new heap of the same element type.
+   * @remarks Time O(N log N), Space O(N)
+   * @param callback - Mapping function (element, index, heap) → element.
+   * @param [thisArg] - Value for `this` inside the callback.
+   * @returns A new heap with mapped elements.
+   */
+  mapSame(callback, thisArg) {
+    const out = this._createInstance();
+    let i = 0;
+    for (const x of this) {
+      const v = thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
+      out.add(v);
+    }
+    return out;
+  }
+  _DEFAULT_COMPARATOR = /* @__PURE__ */ __name((a, b) => {
+    if (typeof a === "object" || typeof b === "object") {
+      throw TypeError("When comparing object types, define a custom comparator in options.");
+    }
+    if (a > b) return 1;
+    if (a < b) return -1;
+    return 0;
+  }, "_DEFAULT_COMPARATOR");
+  _comparator = this._DEFAULT_COMPARATOR;
+  /**
+  * Get the comparator used to order elements.
+  * @remarks Time O(1), Space O(1)
+  * @returns Comparator function.
+  */
+  /**
+   * Get the comparator used to order elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns Comparator function.
+   */
+  get comparator() {
+    return this._comparator;
+  }
+  *_getIterator() {
+    for (const element of this.elements) yield element;
+  }
+  _bubbleUp(index) {
+    const element = this.elements[index];
+    while (index > 0) {
+      const parent = index - 1 >> 1;
+      const parentItem = this.elements[parent];
+      if (this.comparator(parentItem, element) <= 0) break;
+      this.elements[index] = parentItem;
+      index = parent;
+    }
+    this.elements[index] = element;
+    return true;
+  }
+  _sinkDown(index, halfLength) {
+    const element = this.elements[index];
+    while (index < halfLength) {
+      let left = index << 1 | 1;
+      const right = left + 1;
+      let minItem = this.elements[left];
+      if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
+        left = right;
+        minItem = this.elements[right];
+      }
+      if (this.comparator(minItem, element) >= 0) break;
+      this.elements[index] = minItem;
+      index = left;
+    }
+    this.elements[index] = element;
+    return true;
+  }
+  /**
+   * (Protected) Create an empty instance of the same concrete class.
+   * @remarks Time O(1), Space O(1)
+   * @param [options] - Options to override comparator or toElementFn.
+   * @returns A like-kind empty heap instance.
+   */
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    const next = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options ?? {} });
+    return next;
+  }
+  /**
+   * (Protected) Create a like-kind instance seeded by elements.
+   * @remarks Time O(N log N), Space O(N)
+   * @template EM
+   * @template RM
+   * @param [elements] - Iterable of elements or raw values to seed.
+   * @param [options] - Options forwarded to the constructor.
+   * @returns A like-kind heap instance.
+   */
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  /**
+   * (Protected) Spawn an empty like-kind heap instance.
+   * @remarks Time O(1), Space O(1)
+   * @template EM
+   * @template RM
+   * @param [options] - Options forwarded to the constructor.
+   * @returns An empty like-kind heap instance.
+   */
+  _spawnLike(options) {
+    return this._createLike([], options);
+  }
+};
+var FibonacciHeapNode = class {
+  static {
+    __name(this, "FibonacciHeapNode");
+  }
+  element;
+  degree;
+  left;
+  right;
+  child;
+  parent;
+  marked;
+  constructor(element, degree = 0) {
+    this.element = element;
+    this.degree = degree;
+    this.marked = false;
+  }
+};
+var FibonacciHeap = class {
+  static {
+    __name(this, "FibonacciHeap");
+  }
+  /**
+   * 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) {
+    this.clear();
+    this._comparator = comparator || this._defaultComparator;
+    if (typeof this.comparator !== "function") throw new Error("FibonacciHeap: comparator must be a function.");
+  }
+  _root;
+  /**
+   * Get the circular root list head.
+   * @remarks Time O(1), Space O(1)
+   * @returns Root node or undefined.
+   */
+  get root() {
+    return this._root;
+  }
+  _size = 0;
+  get size() {
+    return this._size;
+  }
+  _min;
+  /**
+   * Get the current minimum node.
+   * @remarks Time O(1), Space O(1)
+   * @returns Min node or undefined.
+   */
+  get min() {
+    return this._min;
+  }
+  _comparator;
+  get comparator() {
+    return this._comparator;
+  }
+  clear() {
+    this._root = void 0;
+    this._min = void 0;
+    this._size = 0;
+  }
+  add(element) {
+    this.push(element);
+    return true;
+  }
+  /**
+   * Push an element into the root list.
+   * @remarks Time O(1) amortized, Space O(1)
+   * @param element - Element to insert.
+   * @returns This heap.
+   */
+  push(element) {
+    const node = this.createNode(element);
+    node.left = node;
+    node.right = node;
+    this.mergeWithRoot(node);
+    if (!this.min || this.comparator(node.element, this.min.element) <= 0) this._min = node;
+    this._size++;
+    return this;
+  }
+  peek() {
+    return this.min ? this.min.element : void 0;
+  }
+  /**
+   * Collect nodes from a circular doubly linked list starting at head.
+   * @remarks Time O(K), Space O(K)
+   * @param [head] - Start node of the circular list.
+   * @returns Array of nodes from the list.
+   */
+  consumeLinkedList(head) {
+    const elements = [];
+    if (!head) return elements;
+    let node = head;
+    let started = false;
+    while (true) {
+      if (node === head && started) break;
+      else if (node === head) started = true;
+      elements.push(node);
+      node = node.right;
+    }
+    return elements;
+  }
+  /**
+   * Insert a node into a parent's child list (circular).
+   * @remarks Time O(1), Space O(1)
+   * @param parent - Parent node.
+   * @param node - Child node to insert.
+   * @returns void
+   */
+  mergeWithChild(parent, node) {
+    if (!parent.child) parent.child = node;
+    else {
+      node.right = parent.child.right;
+      node.left = parent.child;
+      parent.child.right.left = node;
+      parent.child.right = node;
+    }
+  }
+  poll() {
+    return this.pop();
+  }
+  /**
+   * Remove and return the minimum element, consolidating the root list.
+   * @remarks Time O(log N) amortized, Space O(1)
+   * @returns Minimum element or undefined.
+   */
+  pop() {
+    if (this._size === 0) return void 0;
+    const z = this.min;
+    if (z.child) {
+      const elements = this.consumeLinkedList(z.child);
+      for (const node of elements) {
+        this.mergeWithRoot(node);
+        node.parent = void 0;
+      }
+    }
+    this.removeFromRoot(z);
+    if (z === z.right) {
+      this._min = void 0;
+      this._root = void 0;
+    } else {
+      this._min = z.right;
+      this._consolidate();
+    }
+    this._size--;
+    return z.element;
+  }
+  /**
+   * Meld another heap into this heap.
+   * @remarks Time O(1), Space O(1)
+   * @param heapToMerge - Another FibonacciHeap to meld into this one.
+   * @returns void
+   */
+  merge(heapToMerge) {
+    if (heapToMerge.size === 0) return;
+    if (this.root && heapToMerge.root) {
+      const thisRoot = this.root, otherRoot = heapToMerge.root;
+      const thisRootRight = thisRoot.right, otherRootLeft = otherRoot.left;
+      thisRoot.right = otherRoot;
+      otherRoot.left = thisRoot;
+      thisRootRight.left = otherRootLeft;
+      otherRootLeft.right = thisRootRight;
+    } else if (!this.root && heapToMerge.root) {
+      this._root = heapToMerge.root;
+    }
+    if (!this.min || heapToMerge.min && this.comparator(heapToMerge.min.element, this.min.element) < 0) {
+      this._min = heapToMerge.min;
+    }
+    this._size += heapToMerge.size;
+    heapToMerge.clear();
+  }
+  createNode(element) {
+    return new FibonacciHeapNode(element);
+  }
+  isEmpty() {
+    return this._size === 0;
+  }
+  _defaultComparator(a, b) {
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+  mergeWithRoot(node) {
+    if (!this.root) this._root = node;
+    else {
+      node.right = this.root.right;
+      node.left = this.root;
+      this.root.right.left = node;
+      this.root.right = node;
+    }
+  }
+  removeFromRoot(node) {
+    if (this.root === node) this._root = node.right;
+    if (node.left) node.left.right = node.right;
+    if (node.right) node.right.left = node.left;
+  }
+  _link(y, x) {
+    this.removeFromRoot(y);
+    y.left = y;
+    y.right = y;
+    this.mergeWithChild(x, y);
+    x.degree++;
+    y.parent = x;
+  }
+  _consolidate() {
+    const A = new Array(this._size);
+    const elements = this.consumeLinkedList(this.root);
+    let x, y, d, t;
+    for (const node of elements) {
+      x = node;
+      d = x.degree;
+      while (A[d]) {
+        y = A[d];
+        if (this.comparator(x.element, y.element) > 0) {
+          t = x;
+          x = y;
+          y = t;
+        }
+        this._link(y, x);
+        A[d] = void 0;
+        d++;
+      }
+      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];
+    }
+  }
+};
+
+// src/data-structures/heap/max-heap.ts
+var MaxHeap = class extends Heap {
+  static {
+    __name(this, "MaxHeap");
+  }
+  /**
+   * Create a max-heap. For objects, supply a custom comparator.
+   * @param elements Optional initial elements.
+   * @param options Optional configuration.
+   */
+  constructor(elements = [], options) {
+    super(elements, {
+      comparator: /* @__PURE__ */ __name((a, b) => {
+        if (typeof a === "object" || typeof b === "object") {
+          throw TypeError(
+            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+          );
+        }
+        if (a < b) return 1;
+        if (a > b) return -1;
+        return 0;
+      }, "comparator"),
+      ...options
+    });
+  }
+};
+
+// src/utils/utils.ts
+function isPrimitiveComparable(value) {
+  const valueType = typeof value;
+  if (valueType === "number") return true;
+  return valueType === "bigint" || valueType === "string" || valueType === "boolean";
+}
+__name(isPrimitiveComparable, "isPrimitiveComparable");
+function tryObjectToPrimitive(obj) {
+  if (typeof obj.valueOf === "function") {
+    const valueOfResult = obj.valueOf();
+    if (valueOfResult !== obj) {
+      if (isPrimitiveComparable(valueOfResult)) return valueOfResult;
+      if (typeof valueOfResult === "object" && valueOfResult !== null) return tryObjectToPrimitive(valueOfResult);
+    }
+  }
+  if (typeof obj.toString === "function") {
+    const stringResult = obj.toString();
+    if (stringResult !== "[object Object]") return stringResult;
+  }
+  return null;
+}
+__name(tryObjectToPrimitive, "tryObjectToPrimitive");
+function isComparable(value, isForceObjectComparable = false) {
+  if (value === null || value === void 0) return false;
+  if (isPrimitiveComparable(value)) return true;
+  if (typeof value !== "object") return false;
+  if (value instanceof Date) return true;
+  if (isForceObjectComparable) return true;
+  const comparableValue = tryObjectToPrimitive(value);
+  if (comparableValue === null || comparableValue === void 0) return false;
+  return isPrimitiveComparable(comparableValue);
+}
+__name(isComparable, "isComparable");
+
+// src/common/index.ts
+var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+  DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+  DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+  return DFSOperation2;
+})(DFSOperation || {});
+var Range = class {
+  constructor(low, high, includeLow = true, includeHigh = true) {
+    this.low = low;
+    this.high = high;
+    this.includeLow = includeLow;
+    this.includeHigh = includeHigh;
+    if (!(isComparable(low) && isComparable(high))) throw new RangeError("low or high is not comparable");
+    if (low > high) throw new RangeError("low must be less than or equal to high");
+  }
+  static {
+    __name(this, "Range");
+  }
+  // Determine whether a key is within the range
+  isInRange(key, comparator) {
+    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+    return lowCheck && highCheck;
+  }
+};
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+/**
+ * data-structure-typed
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+
+exports.DFSOperation = DFSOperation;
+exports.FibonacciHeap = FibonacciHeap;
+exports.FibonacciHeapNode = FibonacciHeapNode;
+exports.Heap = Heap;
+exports.MaxHeap = MaxHeap;
+exports.Range = Range;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map