max-priority-queue-typed 2.5.0 → 2.5.1

package/dist/types/data-structures/binary-tree/binary-tree.d.ts

@@ -350,7 +350,7 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param key - The key to validate.
      * @returns True if the key is valid, false otherwise.
      */
-    isValidKey(key: any): key is K;
+    isValidKey(key: unknown): key is K;
     /**
      * Adds a new node to the tree.
      * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
@@ -363,6 +363,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Add a single node
    *  const tree = new BinaryTree<number>();
@@ -391,6 +412,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // basic BinaryTree creation and insertion
    *  // Create a BinaryTree with entries
@@ -431,6 +473,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Bulk add
    *  const tree = new BinaryTree<number>();
@@ -447,6 +510,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @returns An array of booleans indicating the success of each individual `set` operation.
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Set multiple entries
    *  const tree = new BinaryTree<number, string>();
@@ -468,6 +552,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Combine trees
    *  const t1 = new BinaryTree<number>([1, 2]);
@@ -501,6 +606,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove a node
    *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -513,6 +639,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
    * Search by predicate
   
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Search by predicate
  *  const tree = new BinaryTree<number>([5, 3, 7, 1, 9]);
@@ -538,6 +685,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Get nodes by condition
    *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -562,6 +730,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Get node by key
    *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'child']]);
@@ -587,6 +776,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Retrieve value by key
    *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'left'], [3, 'right']]);
@@ -613,6 +823,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // BinaryTree get and has operations
    *  const tree = new BinaryTree(
@@ -655,6 +886,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove all nodes
    *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -676,6 +928,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Check empty
    *  console.log(new BinaryTree().isEmpty()); // true;
@@ -705,6 +978,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Check BST property
    *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -730,6 +1024,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Get depth of a node
    *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -755,6 +1070,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Get tree height
    *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -805,6 +1141,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Depth-first search traversal
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -827,6 +1184,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // BinaryTree level-order traversal
  *  const tree = new BinaryTree([
@@ -869,6 +1247,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get leaf nodes
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -887,6 +1286,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Level-order grouping
  *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
@@ -907,6 +1327,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Morris traversal (O(1) space)
  *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -929,6 +1370,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Deep copy
    *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -953,6 +1415,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Filter nodes by condition
    *  const tree = new BinaryTree<number>([1, 2, 3, 4]);
@@ -980,6 +1463,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Transform to new tree
    *  const tree = new BinaryTree<number, number>([[1, 10], [2, 20]]);
@@ -1011,6 +1515,27 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Display tree
    *  const tree = new BinaryTree<number>([1, 2, 3]);
@@ -1136,7 +1661,7 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param p - The item to check.
      * @returns True if it's a function.
      */
-    protected _isPredicate(p: any): p is NodePredicate<BinaryTreeNode<K, V>>;
+    protected _isPredicate(p: unknown): p is NodePredicate<BinaryTreeNode<K, V>>;
     /**
      * (Protected) Extracts the key from a key, node, or entry.
      * @remarks Time O(1)