binary-tree-typed 2.5.0 → 2.5.1

package/dist/types/data-structures/hash/hash-map.d.ts

@@ -145,6 +145,27 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Check if empty
    *  const map = new HashMap();
@@ -164,6 +185,27 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove all entries
    *  const map = new HashMap<string, number>([['a', 1], ['b', 2]]);
@@ -176,7 +218,7 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @remarks Time O(1), Space O(1)
      * @returns True if the value is a 2-tuple.
      */
-    isEntry(rawElement: any): rawElement is [K, V];
+    isEntry(rawElement: unknown): rawElement is [K, V];
     /**
      * Insert or replace a single entry.
      * @remarks Time O(1), Space O(1)
@@ -203,6 +245,48 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
       * @example
@@ -239,6 +323,27 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Add multiple entries
    *  const map = new HashMap<string, number>();
@@ -262,6 +367,27 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // HashMap get and has operations
    *  const map = new HashMap<string, number>([
@@ -301,6 +427,27 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Check key existence
    *  const map = new HashMap<string, number>([['a', 1], ['b', 2]]);
@@ -325,6 +472,27 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove entries by key
    *  const map = new HashMap<string, number>([['x', 10], ['y', 20], ['z', 30]]);
@@ -354,6 +522,27 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Create independent copy
    *  const map = new HashMap<string, number>([['a', 1]]);
@@ -380,6 +569,27 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Transform all values
    *  const prices = new HashMap<string, number>([['apple', 1], ['banana', 2]]);
@@ -388,7 +598,7 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
    *     console.log(doubled.get('apple')); // 2;
    *     console.log(doubled.get('banana')); // 4;
      */
-    map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: any): any;
+    map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: unknown): HashMap<K, VM>;
     /**
      * Filter entries into a new map.
      * @remarks Time O(N), Space O(N)
@@ -406,6 +616,27 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // HashMap iteration and filter operations
    *  const map = new HashMap<number, string>([
@@ -432,7 +663,7 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
    *     console.log(values); // contains 3; // 'Bob', 'Eve'
    *     console.log(values); // contains 7;
      */
-    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): any;
+    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): any;
     /**
      * (Protected) Create a like-kind instance and seed it from an iterable.
      * @remarks Time O(N), Space O(N)
@@ -443,10 +674,10 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @param [options] - Options forwarded to the constructor.
      * @returns A like-kind map instance.
      */
-    protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries?: Iterable<[TK, TV] | TR>, options?: any): any;
+    protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries?: Iterable<[TK, TV] | TR>, options?: Record<string, unknown>): this;
     protected _rehashNoObj(): void;
     protected _getIterator(): IterableIterator<[K, V]>;
-    protected _isObjKey(key: any): key is object | ((...args: any[]) => any);
+    protected _isObjKey(key: unknown): key is object | ((...args: unknown[]) => unknown);
     protected _getNoObjKey(key: K): string;
 }
 /**
@@ -561,10 +792,10 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     deleteAt(index: number): boolean;
     isEmpty(): boolean;
-    isEntry(rawElement: any): rawElement is [K, V];
+    isEntry(rawElement: unknown): rawElement is [K, V];
     clear(): void;
-    clone(): any;
-    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): any;
+    clone(): this;
+    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): this;
     /**
      * Map each entry to a new [key, value] pair and preserve order.
      * @remarks Time O(N), Space O(N)
@@ -574,8 +805,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new map of the same class with transformed entries.
      */
-    map<MK, MV>(callback: EntryCallback<K, V, [MK, MV]>, thisArg?: any): any;
+    map<MK, MV>(callback: EntryCallback<K, V, [MK, MV]>, thisArg?: unknown): LinkedHashMap<MK, MV>;
     protected _getIterator(): IterableIterator<[K, V]>;
     protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): boolean;
-    protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries?: Iterable<[TK, TV] | TR>, options?: any): any;
+    protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries?: Iterable<[TK, TV] | TR>, options?: Record<string, unknown>): this;
 }

package/dist/types/data-structures/heap/heap.d.ts

@@ -176,6 +176,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Track heap capacity
    *  const heap = new Heap<number>();
@@ -230,6 +251,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // basic Heap creation and add operation
    *  // Create a min heap (default)
@@ -260,6 +302,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Add multiple elements
    *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -283,6 +346,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Heap with custom comparator (MaxHeap behavior)
    *  interface Task {
@@ -325,6 +409,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Heap for event processing with priority
    *  interface Event {
@@ -399,6 +504,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Check if heap is empty
    *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -420,6 +546,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove all elements
    *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -441,6 +588,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      * @returns True if found.
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Check element existence
    *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -461,6 +629,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove specific element
    *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
@@ -489,6 +678,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      * @returns Array of visited elements.
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Depth-first traversal
    *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -517,6 +727,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Sort elements using heap
    *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
@@ -537,6 +768,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Create independent copy
    *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
@@ -561,6 +813,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Filter elements
    *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
@@ -585,6 +858,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Transform elements
    *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });