max-priority-queue-typed 2.5.0 → 2.5.1

package/dist/umd/max-priority-queue-typed.js

@@ -350,6 +350,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Track heap capacity
     *  const heap = new Heap<number>();
@@ -413,6 +434,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic Heap creation and add operation
     *  // Create a min heap (default)
@@ -446,6 +488,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Add multiple elements
     *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -481,6 +544,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Heap with custom comparator (MaxHeap behavior)
     *  interface Task {
@@ -532,6 +616,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Heap for event processing with priority
     *  interface Event {
@@ -608,6 +713,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check if heap is empty
     *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -631,6 +757,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all elements
     *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -657,6 +804,27 @@ var maxPriorityQueueTyped = (() => {
       * @returns True if found.
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check element existence
     *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -680,6 +848,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove specific element
     *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
@@ -749,6 +938,27 @@ var maxPriorityQueueTyped = (() => {
       * @returns Array of visited elements.
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Depth-first traversal
     *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -805,6 +1015,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Sort elements using heap
     *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
@@ -834,6 +1065,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Create independent copy
     *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
@@ -862,6 +1114,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
@@ -897,6 +1170,27 @@ var maxPriorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });