tree-multimap-typed 2.5.0 → 2.5.1

package/dist/types/data-structures/base/index.d.ts

@@ -1,2 +1,3 @@
 export * from './iterable-entry-base';
 export * from './iterable-element-base';
+export * from './linear-base';

package/dist/types/data-structures/base/iterable-entry-base.d.ts

@@ -17,7 +17,7 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * @returns Iterator of `[K, V]`.
      * @remarks Time O(n) to iterate, Space O(1)
      */
-    [Symbol.iterator](...args: any[]): IterableIterator<[K, V]>;
+    [Symbol.iterator](...args: unknown[]): IterableIterator<[K, V]>;
     /**
      * Iterate over `[key, value]` pairs (may yield `undefined` values).
      * @returns Iterator of `[K, V | undefined]`.
@@ -43,7 +43,7 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * @returns `true` if all pass; otherwise `false`.
      * @remarks Time O(n), Space O(1)
      */
-    every(predicate: EntryCallback<K, V, boolean>, thisArg?: any): boolean;
+    every(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): boolean;
     /**
      * Test whether any entry satisfies the predicate.
      * @param predicate - `(key, value, index, self) => boolean`.
@@ -51,14 +51,14 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * @returns `true` if any passes; otherwise `false`.
      * @remarks Time O(n), Space O(1)
      */
-    some(predicate: EntryCallback<K, V, boolean>, thisArg?: any): boolean;
+    some(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): boolean;
     /**
      * Visit each entry, left-to-right.
      * @param callbackfn - `(key, value, index, self) => void`.
      * @param thisArg - Optional `this` for callback.
      * @remarks Time O(n), Space O(1)
      */
-    forEach(callbackfn: EntryCallback<K, V, void>, thisArg?: any): void;
+    forEach(callbackfn: EntryCallback<K, V, void>, thisArg?: unknown): void;
     /**
      * Find the first entry that matches a predicate.
      * @param callbackfn - `(key, value, index, self) => boolean`.
@@ -66,7 +66,7 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * @returns Matching `[key, value]` or `undefined`.
      * @remarks Time O(n), Space O(1)
      */
-    find(callbackfn: EntryCallback<K, V, boolean>, thisArg?: any): [K, V] | undefined;
+    find(callbackfn: EntryCallback<K, V, boolean>, thisArg?: unknown): [K, V] | undefined;
     /**
      * Whether the given key exists.
      * @param key - Key to test.
@@ -134,17 +134,17 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * Map entries using an implementation-specific strategy.
      * @remarks Time O(n), Space O(n)
      */
-    abstract map(...args: any[]): any;
+    abstract map(...args: unknown[]): unknown;
     /**
      * Filter entries and return the same-species structure.
      * @returns A new instance of the same concrete class (`this` type).
      * @remarks Time O(n), Space O(n)
      */
-    abstract filter(...args: any[]): this;
+    abstract filter(...args: unknown[]): this;
     /**
      * Underlying iterator for the default iteration protocol.
      * @returns Iterator of `[K, V]`.
      * @remarks Time O(n), Space O(1)
      */
-    protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
+    protected abstract _getIterator(...args: unknown[]): IterableIterator<[K, V]>;
 }

package/dist/types/data-structures/base/linear-base.d.ts

@@ -89,7 +89,7 @@ export declare abstract class LinearBase<E, R = any, NODE extends LinkedListNode
      * @returns Index or `-1`.
      * @remarks Time O(n), Space O(1)
      */
-    findIndex(predicate: ElementCallback<E, R, boolean>, thisArg?: any): number;
+    findIndex(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): number;
     /**
      * Concatenate elements and/or containers.
      * @param items - Elements or other containers.
@@ -228,7 +228,7 @@ export declare abstract class LinearBase<E, R = any, NODE extends LinkedListNode
      * @returns Iterator of elements from tail to head.
      * @remarks Time O(n), Space O(1)
      */
-    protected abstract _getReverseIterator(...args: any[]): IterableIterator<E>;
+    protected abstract _getReverseIterator(...args: unknown[]): IterableIterator<E>;
 }
 /**
  * Linked-list specialized linear container.
@@ -324,7 +324,7 @@ export declare abstract class LinearLinkedBase<E, R = any, NODE extends LinkedLi
      * @returns Iterator over nodes.
      * @remarks Time O(n), Space O(1)
      */
-    protected abstract _getNodeIterator(...args: any[]): IterableIterator<NODE>;
+    protected abstract _getNodeIterator(...args: unknown[]): IterableIterator<NODE>;
     /**
      * Get previous node of a given node.
      * @param node - Current node.

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

@@ -282,6 +282,90 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -329,6 +413,69 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -377,6 +524,48 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Rebalance the tree
    *  const avl = new AVLTree<number>();
@@ -418,6 +607,69 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
       * @example

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

@@ -43,6 +43,48 @@ export declare class BinaryIndexedTree implements Iterable<number> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Add delta at index
    *  const bit = new BinaryIndexedTree([1, 2, 3, 4, 5]);
@@ -68,6 +110,48 @@ export declare class BinaryIndexedTree implements Iterable<number> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Set value at index
    *  const bit = new BinaryIndexedTree([1, 2, 3]);
@@ -92,6 +176,48 @@ export declare class BinaryIndexedTree implements Iterable<number> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Get value at index
    *  const bit = new BinaryIndexedTree([1, 2, 3]);
@@ -117,6 +243,48 @@ export declare class BinaryIndexedTree implements Iterable<number> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Prefix sum
    *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
@@ -140,6 +308,48 @@ export declare class BinaryIndexedTree implements Iterable<number> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Range sum
    *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
@@ -166,6 +376,48 @@ export declare class BinaryIndexedTree implements Iterable<number> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Find index with prefix sum ≥ target
    *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
@@ -180,6 +432,27 @@ export declare class BinaryIndexedTree implements Iterable<number> {
      * Time: O(log n)
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Find index with prefix sum > target
    *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
@@ -196,6 +469,27 @@ export declare class BinaryIndexedTree implements Iterable<number> {
      * Time: O(n log n)
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Convert to array
    *  const bit = new BinaryIndexedTree([1, 2, 3]);