d-ary-heap 2.4.0 → 2.5.0

package/dist/index.d.cts

@@ -53,7 +53,7 @@
  *
  * // 4. Access statistics
  * console.log(comparator.stats);
- * // { insert: 1, pop: 2, decreasePriority: 0, total: 3 }
+ * // { insert: 1, pop: 2, decreasePriority: 0, increasePriority: 0, updatePriority: 0, total: 3 }
  *
  * // 5. Reset for next measurement
  * comparator.stats.reset();
@@ -63,12 +63,13 @@
  *
  * For a d-ary heap with n elements:
  *
- * | Operation        | Comparisons (worst case)    |
- * |------------------|----------------------------|
- * | insert           | ⌊log_d(n)⌋                 |
- * | pop              | d × ⌊log_d(n)⌋             |
- * | decreasePriority | ⌊log_d(n)⌋ (upward only)   |
- * | increasePriority | d × ⌊log_d(n)⌋ (downward)  |
+ * | Operation        | Comparisons (worst case)      |
+ * |------------------|-------------------------------|
+ * | insert           | ⌊log_d(n)⌋                    |
+ * | pop              | d × ⌊log_d(n)⌋                |
+ * | increasePriority | ⌊log_d(n)⌋ (moveUp only)      |
+ * | decreasePriority | d × ⌊log_d(n)⌋ (moveDown only)|
+ * | updatePriority   | (d+1) × ⌊log_d(n)⌋ (both)     |
  *
  * The demo visualization compares actual counts against these theoretical bounds.
  *
@@ -80,10 +81,10 @@
 /**
  * Operation types that can be tracked.
  *
- * Note: `increasePriority` is tracked separately because in Dijkstra's algorithm
- * it manifests as decreasePriority (lowering distance = higher priority in min-heap).
+ * Note: `updatePriority` is tracked separately for when the caller doesn't know
+ * whether priority increased or decreased (checks both directions).
  */
-type OperationType = 'insert' | 'pop' | 'decreasePriority' | 'increasePriority';
+type OperationType = 'insert' | 'pop' | 'decreasePriority' | 'increasePriority' | 'updatePriority';
 /**
  * Statistics tracking comparison counts per operation type.
  *
@@ -94,10 +95,12 @@ interface ComparisonStats {
     insert: number;
     /** Comparisons during pop operations (moveDown + bestChildPosition) */
     pop: number;
-    /** Comparisons during decreasePriority operations (moveUp + moveDown) */
+    /** Comparisons during decreasePriority operations (moveDown only) */
     decreasePriority: number;
-    /** Comparisons during increasePriority operations (moveUp) */
+    /** Comparisons during increasePriority operations (moveUp only) */
     increasePriority: number;
+    /** Comparisons during updatePriority operations (moveUp + moveDown) */
+    updatePriority: number;
     /** Total comparisons across all operation types */
     readonly total: number;
     /** Reset all counters to zero */
@@ -212,18 +215,39 @@ declare function theoreticalInsertComparisons(n: number, d: number): number;
  * @returns Theoretical worst-case comparison count
  */
 declare function theoreticalPopComparisons(n: number, d: number): number;
+/**
+ * Calculate theoretical comparison count for an increasePriority operation.
+ *
+ * IncreasePriority performs only moveUp (item became more important).
+ * Worst case: ⌊log_d(n)⌋ comparisons (one per level).
+ *
+ * @param n - Number of elements in heap
+ * @param d - Heap arity
+ * @returns Theoretical worst-case comparison count
+ */
+declare function theoreticalIncreasePriorityComparisons(n: number, d: number): number;
 /**
  * Calculate theoretical comparison count for a decreasePriority operation.
  *
- * DecreasePriority in our implementation calls both moveUp and moveDown
- * for safety, but typically only moveUp executes (upward movement).
- * Worst case: ⌊log_d(n)⌋ comparisons.
+ * DecreasePriority performs only moveDown (item became less important).
+ * Worst case: d × ⌊log_d(n)⌋ comparisons.
  *
  * @param n - Number of elements in heap
  * @param d - Heap arity
- * @returns Theoretical worst-case comparison count (moveUp path)
+ * @returns Theoretical worst-case comparison count
  */
 declare function theoreticalDecreasePriorityComparisons(n: number, d: number): number;
+/**
+ * Calculate theoretical comparison count for an updatePriority operation.
+ *
+ * UpdatePriority performs both moveUp and moveDown (direction unknown).
+ * Worst case: (d + 1) × ⌊log_d(n)⌋ comparisons.
+ *
+ * @param n - Number of elements in heap
+ * @param d - Heap arity
+ * @returns Theoretical worst-case comparison count
+ */
+declare function theoreticalUpdatePriorityComparisons(n: number, d: number): number;
 
 /**
  * d-ary Heap Priority Queue - TypeScript Implementation
@@ -233,8 +257,9 @@ declare function theoreticalDecreasePriorityComparisons(n: number, d: number): n
  * - Min-heap or max-heap behavior via comparator functions
  * - O(1) item lookup using Map for efficient priority updates
  * - O(1) access to highest-priority item
- * - O(log_d n) insert and priority increase operations
- * - O(d · log_d n) pop and priority decrease operations
+ * - O(log_d n) insert and increasePriority operations
+ * - O(d · log_d n) pop and decreasePriority operations
+ * - O((d+1) · log_d n) updatePriority (bidirectional)
  * - Optional instrumentation hooks for performance analysis
  *
  * @version 2.4.0
@@ -314,6 +339,7 @@ interface PriorityQueueOptions<T, K> {
  * - pop(): O(d · log_d n)
  * - increasePriority(): O(log_d n)
  * - decreasePriority(): O(d · log_d n)
+ * - updatePriority(): O((d+1) · log_d n)
  * - contains(): O(1)
  * - len(), isEmpty(), d(): O(1)
  *
@@ -484,6 +510,21 @@ declare class PriorityQueue<T, K = string | number> {
     increasePriorityByIndex(index: number): void;
     /** Alias for increasePriorityByIndex() - snake_case for cross-language consistency */
     increase_priority_by_index(index: number): void;
+    /**
+     * Decrease the priority of the item at the given index.
+     * Time complexity: O(d · log_d n)
+     *
+     * @param index - Index of the item in the heap array
+     * @throws Error if index is out of bounds
+     *
+     * @remarks
+     * This is a lower-level method. Prefer decreasePriority() with the item itself.
+     * The item at the given index should already have its priority value updated
+     * in the container before calling this method.
+     */
+    decreasePriorityByIndex(index: number): void;
+    /** Alias for decreasePriorityByIndex() - snake_case for cross-language consistency */
+    decrease_priority_by_index(index: number): void;
     /**
      * Decrease the priority of an existing item (move toward leaves).
      * Time complexity: O(d · log_d n)
@@ -494,11 +535,26 @@ declare class PriorityQueue<T, K = string | number> {
      * @remarks
      * For min-heap: increasing the priority value decreases importance.
      * For max-heap: decreasing the priority value decreases importance.
-     * This method checks both directions for robustness.
+     * This method only moves items downward. Use updatePriority() if direction is unknown.
      */
     decreasePriority(updatedItem: T): void;
     /** Alias for decreasePriority() - snake_case for cross-language consistency */
     decrease_priority(updatedItem: T): void;
+    /**
+     * Update the priority of an existing item when direction is unknown.
+     * Time complexity: O((d+1) · log_d n) - checks both directions
+     *
+     * @param updatedItem - Item with same identity but updated priority
+     * @throws Error if item not found
+     *
+     * @remarks
+     * Use this method when you don't know whether the priority increased or decreased.
+     * If you know the direction, prefer increasePriority() or decreasePriority() for
+     * better performance (log_d n vs (d+1) · log_d n comparisons).
+     */
+    updatePriority(updatedItem: T): void;
+    /** Alias for updatePriority() - snake_case for cross-language consistency */
+    update_priority(updatedItem: T): void;
     /**
      * Remove and return the highest-priority item.
      * Time complexity: O(d · log_d n)
@@ -647,4 +703,4 @@ declare function reverse<T>(cmp: Comparator<T>): Comparator<T>;
  */
 declare function chain<T>(...comparators: Comparator<T>[]): Comparator<T>;
 
-export { type Comparator, type ComparisonStats, type InstrumentedComparator, type KeyExtractor, type OperationType, type Position, PriorityQueue, type PriorityQueueOptions, chain, createComparisonStats, instrumentComparator, maxBy, maxNumber, maxString, minBy, minNumber, minString, reverse, theoreticalDecreasePriorityComparisons, theoreticalInsertComparisons, theoreticalPopComparisons };
+export { type Comparator, type ComparisonStats, type InstrumentedComparator, type KeyExtractor, type OperationType, type Position, PriorityQueue, type PriorityQueueOptions, chain, createComparisonStats, instrumentComparator, maxBy, maxNumber, maxString, minBy, minNumber, minString, reverse, theoreticalDecreasePriorityComparisons, theoreticalIncreasePriorityComparisons, theoreticalInsertComparisons, theoreticalPopComparisons, theoreticalUpdatePriorityComparisons };

package/dist/index.d.ts

@@ -53,7 +53,7 @@
  *
  * // 4. Access statistics
  * console.log(comparator.stats);
- * // { insert: 1, pop: 2, decreasePriority: 0, total: 3 }
+ * // { insert: 1, pop: 2, decreasePriority: 0, increasePriority: 0, updatePriority: 0, total: 3 }
  *
  * // 5. Reset for next measurement
  * comparator.stats.reset();
@@ -63,12 +63,13 @@
  *
  * For a d-ary heap with n elements:
  *
- * | Operation        | Comparisons (worst case)    |
- * |------------------|----------------------------|
- * | insert           | ⌊log_d(n)⌋                 |
- * | pop              | d × ⌊log_d(n)⌋             |
- * | decreasePriority | ⌊log_d(n)⌋ (upward only)   |
- * | increasePriority | d × ⌊log_d(n)⌋ (downward)  |
+ * | Operation        | Comparisons (worst case)      |
+ * |------------------|-------------------------------|
+ * | insert           | ⌊log_d(n)⌋                    |
+ * | pop              | d × ⌊log_d(n)⌋                |
+ * | increasePriority | ⌊log_d(n)⌋ (moveUp only)      |
+ * | decreasePriority | d × ⌊log_d(n)⌋ (moveDown only)|
+ * | updatePriority   | (d+1) × ⌊log_d(n)⌋ (both)     |
  *
  * The demo visualization compares actual counts against these theoretical bounds.
  *
@@ -80,10 +81,10 @@
 /**
  * Operation types that can be tracked.
  *
- * Note: `increasePriority` is tracked separately because in Dijkstra's algorithm
- * it manifests as decreasePriority (lowering distance = higher priority in min-heap).
+ * Note: `updatePriority` is tracked separately for when the caller doesn't know
+ * whether priority increased or decreased (checks both directions).
  */
-type OperationType = 'insert' | 'pop' | 'decreasePriority' | 'increasePriority';
+type OperationType = 'insert' | 'pop' | 'decreasePriority' | 'increasePriority' | 'updatePriority';
 /**
  * Statistics tracking comparison counts per operation type.
  *
@@ -94,10 +95,12 @@ interface ComparisonStats {
     insert: number;
     /** Comparisons during pop operations (moveDown + bestChildPosition) */
     pop: number;
-    /** Comparisons during decreasePriority operations (moveUp + moveDown) */
+    /** Comparisons during decreasePriority operations (moveDown only) */
     decreasePriority: number;
-    /** Comparisons during increasePriority operations (moveUp) */
+    /** Comparisons during increasePriority operations (moveUp only) */
     increasePriority: number;
+    /** Comparisons during updatePriority operations (moveUp + moveDown) */
+    updatePriority: number;
     /** Total comparisons across all operation types */
     readonly total: number;
     /** Reset all counters to zero */
@@ -212,18 +215,39 @@ declare function theoreticalInsertComparisons(n: number, d: number): number;
  * @returns Theoretical worst-case comparison count
  */
 declare function theoreticalPopComparisons(n: number, d: number): number;
+/**
+ * Calculate theoretical comparison count for an increasePriority operation.
+ *
+ * IncreasePriority performs only moveUp (item became more important).
+ * Worst case: ⌊log_d(n)⌋ comparisons (one per level).
+ *
+ * @param n - Number of elements in heap
+ * @param d - Heap arity
+ * @returns Theoretical worst-case comparison count
+ */
+declare function theoreticalIncreasePriorityComparisons(n: number, d: number): number;
 /**
  * Calculate theoretical comparison count for a decreasePriority operation.
  *
- * DecreasePriority in our implementation calls both moveUp and moveDown
- * for safety, but typically only moveUp executes (upward movement).
- * Worst case: ⌊log_d(n)⌋ comparisons.
+ * DecreasePriority performs only moveDown (item became less important).
+ * Worst case: d × ⌊log_d(n)⌋ comparisons.
  *
  * @param n - Number of elements in heap
  * @param d - Heap arity
- * @returns Theoretical worst-case comparison count (moveUp path)
+ * @returns Theoretical worst-case comparison count
  */
 declare function theoreticalDecreasePriorityComparisons(n: number, d: number): number;
+/**
+ * Calculate theoretical comparison count for an updatePriority operation.
+ *
+ * UpdatePriority performs both moveUp and moveDown (direction unknown).
+ * Worst case: (d + 1) × ⌊log_d(n)⌋ comparisons.
+ *
+ * @param n - Number of elements in heap
+ * @param d - Heap arity
+ * @returns Theoretical worst-case comparison count
+ */
+declare function theoreticalUpdatePriorityComparisons(n: number, d: number): number;
 
 /**
  * d-ary Heap Priority Queue - TypeScript Implementation
@@ -233,8 +257,9 @@ declare function theoreticalDecreasePriorityComparisons(n: number, d: number): n
  * - Min-heap or max-heap behavior via comparator functions
  * - O(1) item lookup using Map for efficient priority updates
  * - O(1) access to highest-priority item
- * - O(log_d n) insert and priority increase operations
- * - O(d · log_d n) pop and priority decrease operations
+ * - O(log_d n) insert and increasePriority operations
+ * - O(d · log_d n) pop and decreasePriority operations
+ * - O((d+1) · log_d n) updatePriority (bidirectional)
  * - Optional instrumentation hooks for performance analysis
  *
  * @version 2.4.0
@@ -314,6 +339,7 @@ interface PriorityQueueOptions<T, K> {
  * - pop(): O(d · log_d n)
  * - increasePriority(): O(log_d n)
  * - decreasePriority(): O(d · log_d n)
+ * - updatePriority(): O((d+1) · log_d n)
  * - contains(): O(1)
  * - len(), isEmpty(), d(): O(1)
  *
@@ -484,6 +510,21 @@ declare class PriorityQueue<T, K = string | number> {
     increasePriorityByIndex(index: number): void;
     /** Alias for increasePriorityByIndex() - snake_case for cross-language consistency */
     increase_priority_by_index(index: number): void;
+    /**
+     * Decrease the priority of the item at the given index.
+     * Time complexity: O(d · log_d n)
+     *
+     * @param index - Index of the item in the heap array
+     * @throws Error if index is out of bounds
+     *
+     * @remarks
+     * This is a lower-level method. Prefer decreasePriority() with the item itself.
+     * The item at the given index should already have its priority value updated
+     * in the container before calling this method.
+     */
+    decreasePriorityByIndex(index: number): void;
+    /** Alias for decreasePriorityByIndex() - snake_case for cross-language consistency */
+    decrease_priority_by_index(index: number): void;
     /**
      * Decrease the priority of an existing item (move toward leaves).
      * Time complexity: O(d · log_d n)
@@ -494,11 +535,26 @@ declare class PriorityQueue<T, K = string | number> {
      * @remarks
      * For min-heap: increasing the priority value decreases importance.
      * For max-heap: decreasing the priority value decreases importance.
-     * This method checks both directions for robustness.
+     * This method only moves items downward. Use updatePriority() if direction is unknown.
      */
     decreasePriority(updatedItem: T): void;
     /** Alias for decreasePriority() - snake_case for cross-language consistency */
     decrease_priority(updatedItem: T): void;
+    /**
+     * Update the priority of an existing item when direction is unknown.
+     * Time complexity: O((d+1) · log_d n) - checks both directions
+     *
+     * @param updatedItem - Item with same identity but updated priority
+     * @throws Error if item not found
+     *
+     * @remarks
+     * Use this method when you don't know whether the priority increased or decreased.
+     * If you know the direction, prefer increasePriority() or decreasePriority() for
+     * better performance (log_d n vs (d+1) · log_d n comparisons).
+     */
+    updatePriority(updatedItem: T): void;
+    /** Alias for updatePriority() - snake_case for cross-language consistency */
+    update_priority(updatedItem: T): void;
     /**
      * Remove and return the highest-priority item.
      * Time complexity: O(d · log_d n)
@@ -647,4 +703,4 @@ declare function reverse<T>(cmp: Comparator<T>): Comparator<T>;
  */
 declare function chain<T>(...comparators: Comparator<T>[]): Comparator<T>;
 
-export { type Comparator, type ComparisonStats, type InstrumentedComparator, type KeyExtractor, type OperationType, type Position, PriorityQueue, type PriorityQueueOptions, chain, createComparisonStats, instrumentComparator, maxBy, maxNumber, maxString, minBy, minNumber, minString, reverse, theoreticalDecreasePriorityComparisons, theoreticalInsertComparisons, theoreticalPopComparisons };
+export { type Comparator, type ComparisonStats, type InstrumentedComparator, type KeyExtractor, type OperationType, type Position, PriorityQueue, type PriorityQueueOptions, chain, createComparisonStats, instrumentComparator, maxBy, maxNumber, maxString, minBy, minNumber, minString, reverse, theoreticalDecreasePriorityComparisons, theoreticalIncreasePriorityComparisons, theoreticalInsertComparisons, theoreticalPopComparisons, theoreticalUpdatePriorityComparisons };

package/dist/index.js

@@ -271,6 +271,28 @@ var PriorityQueue = class _PriorityQueue {
   increase_priority_by_index(index) {
     this.increasePriorityByIndex(index);
   }
+  /**
+   * Decrease the priority of the item at the given index.
+   * Time complexity: O(d · log_d n)
+   *
+   * @param index - Index of the item in the heap array
+   * @throws Error if index is out of bounds
+   *
+   * @remarks
+   * This is a lower-level method. Prefer decreasePriority() with the item itself.
+   * The item at the given index should already have its priority value updated
+   * in the container before calling this method.
+   */
+  decreasePriorityByIndex(index) {
+    if (index < 0 || index >= this.container.length) {
+      throw new Error("Index out of bounds");
+    }
+    this.moveDown(index);
+  }
+  /** Alias for decreasePriorityByIndex() - snake_case for cross-language consistency */
+  decrease_priority_by_index(index) {
+    this.decreasePriorityByIndex(index);
+  }
   /**
    * Decrease the priority of an existing item (move toward leaves).
    * Time complexity: O(d · log_d n)
@@ -281,7 +303,7 @@ var PriorityQueue = class _PriorityQueue {
    * @remarks
    * For min-heap: increasing the priority value decreases importance.
    * For max-heap: decreasing the priority value decreases importance.
-   * This method checks both directions for robustness.
+   * This method only moves items downward. Use updatePriority() if direction is unknown.
    */
   decreasePriority(updatedItem) {
     this.onBeforeOperation?.("decreasePriority");
@@ -292,7 +314,6 @@ var PriorityQueue = class _PriorityQueue {
       throw new Error("Item not found in priority queue");
     }
     this.container[index] = updatedItem;
-    this.moveUp(index);
     this.moveDown(index);
     this.onAfterOperation?.();
   }
@@ -300,6 +321,35 @@ var PriorityQueue = class _PriorityQueue {
   decrease_priority(updatedItem) {
     this.decreasePriority(updatedItem);
   }
+  /**
+   * Update the priority of an existing item when direction is unknown.
+   * Time complexity: O((d+1) · log_d n) - checks both directions
+   *
+   * @param updatedItem - Item with same identity but updated priority
+   * @throws Error if item not found
+   *
+   * @remarks
+   * Use this method when you don't know whether the priority increased or decreased.
+   * If you know the direction, prefer increasePriority() or decreasePriority() for
+   * better performance (log_d n vs (d+1) · log_d n comparisons).
+   */
+  updatePriority(updatedItem) {
+    this.onBeforeOperation?.("updatePriority");
+    const key = this.keyExtractor(updatedItem);
+    const index = this.positions.get(key);
+    if (index === void 0) {
+      this.onAfterOperation?.();
+      throw new Error("Item not found in priority queue");
+    }
+    this.container[index] = updatedItem;
+    this.moveUp(index);
+    this.moveDown(index);
+    this.onAfterOperation?.();
+  }
+  /** Alias for updatePriority() - snake_case for cross-language consistency */
+  update_priority(updatedItem) {
+    this.updatePriority(updatedItem);
+  }
   /**
    * Remove and return the highest-priority item.
    * Time complexity: O(d · log_d n)
@@ -497,14 +547,16 @@ function createComparisonStats() {
     pop: 0,
     decreasePriority: 0,
     increasePriority: 0,
+    updatePriority: 0,
     get total() {
-      return this.insert + this.pop + this.decreasePriority + this.increasePriority;
+      return this.insert + this.pop + this.decreasePriority + this.increasePriority + this.updatePriority;
     },
     reset() {
       this.insert = 0;
       this.pop = 0;
       this.decreasePriority = 0;
       this.increasePriority = 0;
+      this.updatePriority = 0;
     }
   };
   return stats;
@@ -540,10 +592,20 @@ function theoreticalPopComparisons(n, d) {
   const height = Math.floor(Math.log(n) / Math.log(d));
   return d * height;
 }
-function theoreticalDecreasePriorityComparisons(n, d) {
+function theoreticalIncreasePriorityComparisons(n, d) {
   if (n <= 1) return 0;
   return Math.floor(Math.log(n) / Math.log(d));
 }
+function theoreticalDecreasePriorityComparisons(n, d) {
+  if (n <= 1) return 0;
+  const height = Math.floor(Math.log(n) / Math.log(d));
+  return d * height;
+}
+function theoreticalUpdatePriorityComparisons(n, d) {
+  if (n <= 1) return 0;
+  const height = Math.floor(Math.log(n) / Math.log(d));
+  return (d + 1) * height;
+}
 /**
  * d-ary Heap Priority Queue - TypeScript Implementation
  *
@@ -552,8 +614,9 @@ function theoreticalDecreasePriorityComparisons(n, d) {
  * - Min-heap or max-heap behavior via comparator functions
  * - O(1) item lookup using Map for efficient priority updates
  * - O(1) access to highest-priority item
- * - O(log_d n) insert and priority increase operations
- * - O(d · log_d n) pop and priority decrease operations
+ * - O(log_d n) insert and increasePriority operations
+ * - O(d · log_d n) pop and decreasePriority operations
+ * - O((d+1) · log_d n) updatePriority (bidirectional)
  * - Optional instrumentation hooks for performance analysis
  *
  * @version 2.4.0
@@ -622,7 +685,7 @@ function theoreticalDecreasePriorityComparisons(n, d) {
  *
  * // 4. Access statistics
  * console.log(comparator.stats);
- * // { insert: 1, pop: 2, decreasePriority: 0, total: 3 }
+ * // { insert: 1, pop: 2, decreasePriority: 0, increasePriority: 0, updatePriority: 0, total: 3 }
  *
  * // 5. Reset for next measurement
  * comparator.stats.reset();
@@ -632,12 +695,13 @@ function theoreticalDecreasePriorityComparisons(n, d) {
  *
  * For a d-ary heap with n elements:
  *
- * | Operation        | Comparisons (worst case)    |
- * |------------------|----------------------------|
- * | insert           | ⌊log_d(n)⌋                 |
- * | pop              | d × ⌊log_d(n)⌋             |
- * | decreasePriority | ⌊log_d(n)⌋ (upward only)   |
- * | increasePriority | d × ⌊log_d(n)⌋ (downward)  |
+ * | Operation        | Comparisons (worst case)      |
+ * |------------------|-------------------------------|
+ * | insert           | ⌊log_d(n)⌋                    |
+ * | pop              | d × ⌊log_d(n)⌋                |
+ * | increasePriority | ⌊log_d(n)⌋ (moveUp only)      |
+ * | decreasePriority | d × ⌊log_d(n)⌋ (moveDown only)|
+ * | updatePriority   | (d+1) × ⌊log_d(n)⌋ (both)     |
  *
  * The demo visualization compares actual counts against these theoretical bounds.
  *
@@ -657,6 +721,6 @@ function theoreticalDecreasePriorityComparisons(n, d) {
  * @copyright 2023-2025 Eric Jacopin
  */
 
-export { PriorityQueue, chain, createComparisonStats, instrumentComparator, maxBy, maxNumber, maxString, minBy, minNumber, minString, reverse, theoreticalDecreasePriorityComparisons, theoreticalInsertComparisons, theoreticalPopComparisons };
+export { PriorityQueue, chain, createComparisonStats, instrumentComparator, maxBy, maxNumber, maxString, minBy, minNumber, minString, reverse, theoreticalDecreasePriorityComparisons, theoreticalIncreasePriorityComparisons, theoreticalInsertComparisons, theoreticalPopComparisons, theoreticalUpdatePriorityComparisons };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map