priority-queue-typed 2.5.0 → 2.5.1

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

@@ -353,6 +353,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Track heap capacity
     *  const heap = new Heap<number>();
@@ -416,6 +437,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic Heap creation and add operation
     *  // Create a min heap (default)
@@ -449,6 +491,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Add multiple elements
     *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -484,6 +547,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Heap with custom comparator (MaxHeap behavior)
     *  interface Task {
@@ -535,6 +619,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Heap for event processing with priority
     *  interface Event {
@@ -611,6 +716,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check if heap is empty
     *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -634,6 +760,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all elements
     *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -660,6 +807,27 @@ var priorityQueueTyped = (() => {
       * @returns True if found.
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check element existence
     *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -683,6 +851,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove specific element
     *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
@@ -752,6 +941,27 @@ var priorityQueueTyped = (() => {
       * @returns Array of visited elements.
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Depth-first traversal
     *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -808,6 +1018,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Sort elements using heap
     *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
@@ -837,6 +1068,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Create independent copy
     *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
@@ -865,6 +1117,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
@@ -900,6 +1173,27 @@ var priorityQueueTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });