data-structure-typed 2.5.2 → 2.6.0

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

@@ -213,16 +213,6 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Check empty
-   *  console.log(new TreeMap().isEmpty()); // true;
-     */
-    isEmpty(): boolean;
-    /**
-     * Set or overwrite a value for a key.
-     * @remarks Expected time O(log n)
-     
-     
      
      
      
@@ -258,6 +248,14 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+      * @example
+   * // Check empty
+   *  console.log(new TreeMap().isEmpty()); // true;
+     */
+    isEmpty(): boolean;
+    /**
+     * Set or overwrite a value for a key.
+     * @remarks Expected time O(log n)
      
      
      
@@ -388,31 +386,6 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Sorted dictionary for a contact book
-   *  const contacts = new TreeMap<string, string>([
-   *       ['Bob', '555-0102'],
-   *       ['Alice', '555-0101'],
-   *       ['Charlie', '555-0103']
-   *     ]);
-   *
-   *     // Contacts are automatically sorted by name
-   *     console.log([...contacts.keys()]); // ['Alice', 'Bob', 'Charlie'];
-   *     console.log(contacts.get('Bob')); // '555-0102';
-   *
-   *     // Find the first contact alphabetically after 'B'
-   *     console.log(contacts.ceiling('B')); // ['Bob', '555-0102'];
-   *
-   *     // Find contacts in range
-   *     console.log(contacts.rangeSearch(['Alice', 'Bob'])); // [
-   *  //      ['Alice', '555-0101'],
-   *  //      ['Bob', '555-0102']
-   *  //    ];
-     */
-    set(key: K, value: V | undefined): this;
-    /**
-     * Get the value under a key.
-     * @remarks Expected time O(log n)
      
      
      
@@ -485,6 +458,34 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+      * @example
+   * // Sorted dictionary for a contact book
+   *  const contacts = new TreeMap<string, string>([
+   *       ['Bob', '555-0102'],
+   *       ['Alice', '555-0101'],
+   *       ['Charlie', '555-0103']
+   *     ]);
+   *
+   *     // Contacts are automatically sorted by name
+   *     console.log([...contacts.keys()]); // ['Alice', 'Bob', 'Charlie'];
+   *     console.log(contacts.get('Bob')); // '555-0102';
+   *
+   *     // Find the first contact alphabetically after 'B'
+   *     console.log(contacts.ceiling('B')); // ['Bob', '555-0102'];
+   *
+   *     // Find contacts in range
+   *     console.log(contacts.rangeSearch(['Alice', 'Bob'])); // [
+   *  //      ['Alice', '555-0101'],
+   *  //      ['Bob', '555-0102']
+   *  //    ];
+     */
+    set(key: K, value: V | undefined): this;
+    /**
+     * Set multiple key-value pairs at once.
+     * @remarks Expected time O(m log n), where m is the number of entries.
+     * @param entries - Iterable of `[key, value]` tuples.
+     * @returns Array of booleans indicating whether each entry was successfully set.
+    
      
      
      
@@ -512,6 +513,16 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+      * @example
+   * // Set multiple key-value pairs
+   *  const tm = new TreeMap<number, string>();
+   *     tm.setMany([[1, 'a'], [2, 'b'], [3, 'c']]);
+   *     console.log(tm.size); // 3;
+     */
+    setMany(entries: Iterable<[K, V | undefined]>): boolean[];
+    /**
+     * Get the value under a key.
+     * @remarks Expected time O(log n)
      
      
      
@@ -582,22 +593,6 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Configuration registry with typed lookups
-   *  const config = new TreeMap<string, number>([
-   *       ['maxRetries', 3],
-   *       ['timeout', 5000],
-   *       ['poolSize', 10]
-   *     ]);
-   *
-   *     console.log(config.get('timeout')); // 5000;
-   *     console.log(config.get('missing')); // undefined;
-   *     console.log(config.size); // 3;
-     */
-    get(key: K): V | undefined;
-    /**
-     * Test whether a key exists.
-     * @remarks Expected time O(log n)
      
      
      
@@ -732,6 +727,22 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+      * @example
+   * // Configuration registry with typed lookups
+   *  const config = new TreeMap<string, number>([
+   *       ['maxRetries', 3],
+   *       ['timeout', 5000],
+   *       ['poolSize', 10]
+   *     ]);
+   *
+   *     console.log(config.get('timeout')); // 5000;
+   *     console.log(config.get('missing')); // undefined;
+   *     console.log(config.size); // 3;
+     */
+    get(key: K): V | undefined;
+    /**
+     * Test whether a key exists.
+     * @remarks Expected time O(log n)
      
      
      
@@ -767,22 +778,6 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Feature flag checking
-   *  const flags = new TreeMap<string, boolean>([
-   *       ['darkMode', true],
-   *       ['betaFeature', false],
-   *       ['notifications', true]
-   *     ]);
-   *
-   *     console.log(flags.has('darkMode')); // true;
-   *     console.log(flags.has('unknownFlag')); // false;
-     */
-    has(key: K): boolean;
-    /**
-     * Delete a key.
-     * @returns `true` if the key existed; otherwise `false`.
-     * @remarks Expected time O(log n)
      
      
      
@@ -953,28 +948,21 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
       * @example
-   * // Session management with expiry
-   *  const sessions = new TreeMap<string, number>([
-   *       ['sess_abc', Date.now()],
-   *       ['sess_def', Date.now()],
-   *       ['sess_ghi', Date.now()]
+   * // Feature flag checking
+   *  const flags = new TreeMap<string, boolean>([
+   *       ['darkMode', true],
+   *       ['betaFeature', false],
+   *       ['notifications', true]
    *     ]);
    *
-   *     console.log(sessions.size); // 3;
-   *     sessions.delete('sess_def');
-   *     console.log(sessions.has('sess_def')); // false;
-   *     console.log(sessions.size); // 2;
+   *     console.log(flags.has('darkMode')); // true;
+   *     console.log(flags.has('unknownFlag')); // false;
      */
-    delete(key: K): boolean;
+    has(key: K): boolean;
     /**
-     * Remove all entries.
-     
-     
-     
-     
-     
-     
-     
+     * Delete a key.
+     * @returns `true` if the key existed; otherwise `false`.
+     * @remarks Expected time O(log n)
      
      
      
@@ -1126,15 +1114,6 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Remove all
-   *  const tm = new TreeMap<number, string>([[1, 'a']]);
-   *       tm.clear();
-   *       console.log(tm.isEmpty()); // true;
-     */
-    clear(): void;
-    /**
-     * Iterate over keys in ascending order.
      
      
      
@@ -1188,6 +1167,29 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+      * @example
+   * // Session management with expiry
+   *  const sessions = new TreeMap<string, number>([
+   *       ['sess_abc', Date.now()],
+   *       ['sess_def', Date.now()],
+   *       ['sess_ghi', Date.now()]
+   *     ]);
+   *
+   *     console.log(sessions.size); // 3;
+   *     sessions.delete('sess_def');
+   *     console.log(sessions.has('sess_def')); // false;
+   *     console.log(sessions.size); // 2;
+     */
+    delete(key: K): boolean;
+    /**
+     * Delete all entries matching a predicate.
+     * @remarks Time O(N), Space O(N)
+     * @param predicate - Function (key, value, index, map) → boolean; return true to delete.
+     * @returns True if at least one entry was deleted.
+     */
+    deleteWhere(predicate: (key: K, value: V | undefined, index: number, map: this) => boolean): boolean;
+    /**
+     * Remove all entries.
      
      
      
@@ -1293,17 +1295,6 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Get sorted keys
-   *  const tm = new TreeMap<number, string>([[3, 'c'], [1, 'a']]);
-   *       console.log([...tm.keys()]); // [1, 3];
-     */
-    keys(): IterableIterator<K>;
-    private _entryFromKey;
-    /**
-     * Iterate over values in ascending key order.
-     *
-     * Note: values may be `undefined` (TreeMap allows storing `undefined`, like native `Map`).
      
      
      
@@ -1392,6 +1383,15 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+      * @example
+   * // Remove all
+   *  const tm = new TreeMap<number, string>([[1, 'a']]);
+   *       tm.clear();
+   *       console.log(tm.isEmpty()); // true;
+     */
+    clear(): void;
+    /**
+     * Iterate over keys in ascending order.
      
      
      
@@ -1462,16 +1462,6 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Get values in key order
-   *  const tm = new TreeMap<number, string>([[2, 'b'], [1, 'a']]);
-   *       console.log([...tm.values()]); // ['a', 'b'];
-     */
-    values(): IterableIterator<V | undefined>;
-    /**
-     * Iterate over `[key, value]` entries in ascending key order.
-     *
-     * Note: values may be `undefined`.
      
      
      
@@ -1595,6 +1585,17 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+      * @example
+   * // Get sorted keys
+   *  const tm = new TreeMap<number, string>([[3, 'c'], [1, 'a']]);
+   *       console.log([...tm.keys()]); // [1, 3];
+     */
+    keys(): IterableIterator<K>;
+    private _entryFromKey;
+    /**
+     * Iterate over values in ascending key order.
+     *
+     * Note: values may be `undefined` (TreeMap allows storing `undefined`, like native `Map`).
      
      
      
@@ -1630,17 +1631,6 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Iterate key-value pairs
-   *  const tm = new TreeMap<number, string>([[3, 'c'], [1, 'a'], [2, 'b']]);
-   *       console.log([...tm.entries()]); // [[1, 'a'], [2, 'b'], [3, 'c']];
-     */
-    entries(): IterableIterator<[K, V | undefined]>;
-    [Symbol.iterator](): IterableIterator<[K, V | undefined]>;
-    /**
-     * Visit each entry in ascending key order.
-     *
-     * Note: callback value may be `undefined`.
      
      
      
@@ -1800,19 +1790,15 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
       * @example
-   * // Execute for each entry
-   *  const tm = new TreeMap<number, string>([[1, 'a'], [2, 'b']]);
-   *       const pairs: string[] = [];
-   *       tm.forEach((v, k) => pairs.push(`${k}:${v}`));
-   *       console.log(pairs); // ['1:a', '2:b'];
+   * // Get values in key order
+   *  const tm = new TreeMap<number, string>([[2, 'b'], [1, 'a']]);
+   *       console.log([...tm.values()]); // ['a', 'b'];
      */
-    forEach(cb: (value: V | undefined, key: K, map: TreeMap<K, V>) => void, thisArg?: unknown): void;
+    values(): IterableIterator<V | undefined>;
     /**
-     * Create a new TreeMap by mapping each entry to a new `[key, value]` entry.
+     * Iterate over `[key, value]` entries in ascending key order.
      *
-     * This mirrors `RedBlackTree.map`: mapping produces a new ordered container.
-     * @remarks Time O(n log n) expected, Space O(n)
-     
+     * Note: values may be `undefined`.
      
      
      
@@ -1970,18 +1956,499 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Transform entries
-   *  const tm = new TreeMap<number, number>([[1, 10], [2, 20]]);
-   *       const doubled = tm.map((v, k) => [k, (v ?? 0) * 2] as [number, number]);
-   *       console.log([...doubled.values()]); // [20, 40];
-     */
-    map<MK, MV>(callbackfn: TreeMapEntryCallback<K, V, [MK, MV], TreeMap<K, V>>, options?: Omit<TreeMapOptions<MK, MV>, 'toEntryFn'> & {
-        comparator?: (a: MK, b: MK) => number;
-    }, thisArg?: unknown): TreeMap<MK, MV>;
-    /**
-     * Create a new TreeMap containing only entries that satisfy the predicate.
-     * @remarks Time O(n log n) expected, Space O(n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Iterate key-value pairs
+   *  const tm = new TreeMap<number, string>([[3, 'c'], [1, 'a'], [2, 'b']]);
+   *       console.log([...tm.entries()]); // [[1, 'a'], [2, 'b'], [3, 'c']];
+     */
+    entries(): IterableIterator<[K, V | undefined]>;
+    [Symbol.iterator](): IterableIterator<[K, V | undefined]>;
+    /**
+     * Visit each entry in ascending key order.
+     *
+     * Note: callback value may be `undefined`.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Execute for each entry
+   *  const tm = new TreeMap<number, string>([[1, 'a'], [2, 'b']]);
+   *       const pairs: string[] = [];
+   *       tm.forEach((v, k) => pairs.push(`${k}:${v}`));
+   *       console.log(pairs); // ['1:a', '2:b'];
+     */
+    forEach(cb: (value: V | undefined, key: K, map: TreeMap<K, V>) => void, thisArg?: unknown): void;
+    /**
+     * Create a new TreeMap by mapping each entry to a new `[key, value]` entry.
+     *
+     * This mirrors `RedBlackTree.map`: mapping produces a new ordered container.
+     * @remarks Time O(n log n) expected, Space O(n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Transform entries
+   *  const tm = new TreeMap<number, number>([[1, 10], [2, 20]]);
+   *       const doubled = tm.map((v, k) => [k, (v ?? 0) * 2] as [number, number]);
+   *       console.log([...doubled.values()]); // [20, 40];
+     */
+    map<MK, MV>(callbackfn: TreeMapEntryCallback<K, V, [MK, MV], TreeMap<K, V>>, options?: Omit<TreeMapOptions<MK, MV>, 'toEntryFn'> & {
+        comparator?: (a: MK, b: MK) => number;
+    }, thisArg?: unknown): TreeMap<MK, MV>;
+    /**
+     * Create a new TreeMap containing only entries that satisfy the predicate.
+     * @remarks Time O(n log n) expected, Space O(n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -2287,6 +2754,41 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -2452,6 +2954,41 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -2617,6 +3154,41 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -2804,15 +3376,117 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Find matching entry
-   *  const tm = new TreeMap<number, string>([[1, 'a'], [2, 'b']]);
-   *       console.log(tm.find(v => v === 'b')?.[0]); // 2;
-     */
-    find(callbackfn: TreeMapEntryCallback<K, V, boolean, TreeMap<K, V>>, thisArg?: unknown): [K, V | undefined] | undefined;
-    /**
-     * Materialize the map into an array of `[key, value]` tuples.
-     * @remarks Time O(n), Space O(n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Find matching entry
+   *  const tm = new TreeMap<number, string>([[1, 'a'], [2, 'b']]);
+   *       console.log(tm.find(v => v === 'b')?.[0]); // 2;
+     */
+    find(callbackfn: TreeMapEntryCallback<K, V, boolean, TreeMap<K, V>>, thisArg?: unknown): [K, V | undefined] | undefined;
+    /**
+     * Materialize the map into an array of `[key, value]` tuples.
+     * @remarks Time O(n), Space O(n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -2939,6 +3613,18 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+      * @example
+   * // Convert to array
+   *  const tm = new TreeMap<number, string>([[2, 'b'], [1, 'a']]);
+   *       console.log(tm.toArray()); // [[1, 'a'], [2, 'b']];
+     */
+    toArray(): Array<[K, V | undefined]>;
+    /**
+     * Print a human-friendly representation.
+     * @remarks Time O(n), Space O(n)
+     
+     
+     
      
      
      
@@ -2971,15 +3657,6 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
-      * @example
-   * // Convert to array
-   *  const tm = new TreeMap<number, string>([[2, 'b'], [1, 'a']]);
-   *       console.log(tm.toArray()); // [[1, 'a'], [2, 'b']];
-     */
-    toArray(): Array<[K, V | undefined]>;
-    /**
-     * Print a human-friendly representation.
-     * @remarks Time O(n), Space O(n)
      
      
      
@@ -3173,6 +3850,13 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3238,6 +3922,13 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3287,6 +3978,13 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3338,6 +4036,13 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3475,6 +4180,34 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3644,6 +4377,34 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3797,6 +4558,34 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3950,6 +4739,34 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -4104,6 +4921,34 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -4193,8 +5038,22 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      * Returns keys by rank range (0-indexed, inclusive on both ends).
      * @remarks Time O(log n + k). Requires `enableOrderStatistic: true`.
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
-   * // Pagination with rangeByRank
+   * // Pagination by position in tree order
    *  const tree = new TreeMap<number>(
    *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
    *         { enableOrderStatistic: true }
@@ -4350,6 +5209,41 @@ export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+