max-priority-queue-typed 2.3.0 → 2.4.1

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

@@ -52,7 +52,7 @@ export declare abstract class LinearBase<E, R = any, NODE extends LinkedListNode
      * @param options - `{ maxLen?, ... }` bounds/behavior options.
      * @remarks Time O(1), Space O(1)
      */
-    protected constructor(options?: LinearBaseOptions<E, R>);
+    constructor(options?: LinearBaseOptions<E, R>);
     /**
      * Element count.
      * @returns Number of elements.
@@ -91,12 +91,12 @@ export declare abstract class LinearBase<E, R = any, NODE extends LinkedListNode
      */
     findIndex(predicate: ElementCallback<E, R, boolean>, thisArg?: any): number;
     /**
-     * Concatenate multiple containers of the same species.
-     * @param items - Other lists to append.
+     * Concatenate elements and/or containers.
+     * @param items - Elements or other containers.
      * @returns New container with combined elements (`this` type).
      * @remarks Time O(sum(length)), Space O(sum(length))
      */
-    concat(...items: this[]): this;
+    concat(...items: (E | this)[]): this;
     /**
      * In-place stable order via array sort semantics.
      * @param compareFn - Comparator `(a, b) => number`.
@@ -238,7 +238,7 @@ export declare abstract class LinearBase<E, R = any, NODE extends LinkedListNode
  * @remarks Time O(1), Space O(1)
  */
 export declare abstract class LinearLinkedBase<E, R = any, NODE extends LinkedListNode<E> = LinkedListNode<E>> extends LinearBase<E, R, NODE> {
-    protected constructor(options?: LinearBaseOptions<E, R>);
+    constructor(options?: LinearBaseOptions<E, R>);
     /**
      * Linked-list optimized `indexOf` (forwards scan).
      * @param searchElement - Value to match.
@@ -261,7 +261,7 @@ export declare abstract class LinearLinkedBase<E, R = any, NODE extends LinkedLi
      * @returns New list with combined elements (`this` type).
      * @remarks Time O(sum(length)), Space O(sum(length))
      */
-    concat(...items: LinearBase<E, R>[]): this;
+    concat(...items: (E | LinearBase<E, R>)[]): this;
     /**
      * Slice via forward iteration (no random access required).
      * @param start - Inclusive start (supports negative index).

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BinaryTreeOptions, BinaryTreePrintOptions, BTNEntry, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodeDisplayLayout, NodePredicate, RBTNColor, ToEntryFn } from '../../types';
+import type { BinaryTreeDeleteResult, BinaryTreeOptions, BinaryTreePrintOptions, BTNEntry, BTNRep, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodeDisplayLayout, NodePredicate, RBTNColor, ToEntryFn } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from '../base';
 import { Range } from '../../common';
@@ -291,14 +291,14 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @returns True if duplicates are allowed, false otherwise.
      */
     get isDuplicate(): boolean;
-    protected _store: Map<K, V | undefined>;
+    protected _store: Map<K, BinaryTreeNode<K, V>>;
     /**
      * Gets the external value store (used in Map mode).
      * @remarks Time O(1)
      *
      * @returns The map storing key-value pairs.
      */
-    get store(): Map<K, V | undefined>;
+    get store(): Map<K, BinaryTreeNode<K, V>>;
     protected _root?: BinaryTreeNode<K, V> | null | undefined;
     /**
      * Gets the root node of the tree.
@@ -482,10 +482,10 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * Deletes a node from 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 finds the node, and if it has two children, swaps it with the rightmost node of its left subtree (in-order predecessor) before deleting. Time O(N) in the worst case. O(N) to find the node (`getNode`) and O(H) (which is O(N) worst-case) to find the rightmost node. Space O(1) (if `getNode` is iterative, which it is).
      *
-     * @param keyNodeOrEntry - The node to delete.
+     * @param keyNodeEntryRawOrPredicate - The node to delete.
      * @returns An array containing deletion results (for compatibility with self-balancing trees).
      */
-    delete(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
+    delete(keyNodeEntryRawOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
     search(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, onlyOne?: boolean): (K | undefined)[];
     search<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, onlyOne: boolean, callback: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
     /**
@@ -792,7 +792,7 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param value - The value.
      * @returns True if successful.
      */
-    protected _setValue(key: K | null | undefined, value: V | undefined): false | Map<K, V | undefined>;
+    protected _setValue(key: K | null | undefined, value: V | undefined): boolean;
     /**
      * (Protected) Clears all nodes from the tree.
      * @remarks Time O(1)

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

@@ -130,7 +130,8 @@ export declare class BSTNode<K = any, V = any> {
  *  // Create a simple BST with numeric keys
  *     const bst = new BST<number>([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
  *
- *     bst.print();
+ *     // Keep the example output in source comments but avoid noisy test logs.
+ *     await withMutedConsole(() => bst.print());
  *     //         _______8__________
  *     //        /                  \
  *     //     ___4___          ____12_____

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

@@ -4,7 +4,7 @@ export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
 export * from './red-black-tree';
-export * from './avl-tree-multi-map';
 export * from './tree-multi-map';
-export * from './tree-counter';
-export * from './avl-tree-counter';
+export * from './tree-set';
+export * from './tree-map';
+export * from './tree-multi-set';

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, CRUD, EntryCallback, FamilyPosition, RBTNColor, RedBlackTreeOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BTNRep, CRUD, EntryCallback, FamilyPosition, NodePredicate, RBTNColor, RedBlackTreeOptions } from '../../types';
 import { BST } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any> {
@@ -13,12 +13,11 @@ export declare class RedBlackTreeNode<K = any, V = any> {
     value?: V;
     parent?: RedBlackTreeNode<K, V>;
     /**
-     * Create a Red-Black Tree and optionally bulk-insert items.
-     * @remarks Time O(n log n), Space O(n)
-     * @param key - See parameter type for details.
-     * @param [value]- See parameter type for details.
-     * @param color - See parameter type for details.
-     * @returns New RedBlackTree instance.
+     * Create a Red-Black Tree node.
+     * @remarks Time O(1), Space O(1)
+     * @param key - Node key.
+     * @param [value] - Node value (unused in map mode trees).
+     * @param color - Node color.
      */
     constructor(key: K, value?: V, color?: RBTNColor);
     _left?: RedBlackTreeNode<K, V> | null | undefined;
@@ -104,7 +103,7 @@ export declare class RedBlackTreeNode<K = any, V = any> {
 }
 /**
  * Represents a Red-Black Tree (self-balancing BST) supporting map-like mode and stable O(log n) updates.
- * @remarks Time O(1), Space O(1)
+ * @remarks Operation complexity depends on the method; see each method's docs.
  * @template K
  * @template V
  * @template R
@@ -207,6 +206,24 @@ export declare class RedBlackTreeNode<K = any, V = any> {
 export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implements IBinaryTree<K, V, R> {
     constructor(keysNodesEntriesOrRaws?: Iterable<K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: RedBlackTreeOptions<K, V, R>);
     protected _root: RedBlackTreeNode<K, V> | undefined;
+    /**
+     * (Internal) Header sentinel:
+     * - header.parent -> root
+     * - header._left  -> min (or NIL)
+     * - header._right -> max (or NIL)
+     *
+     * IMPORTANT:
+     * - This header is NOT part of the actual tree.
+     * - Do NOT use `header.left` / `header.right` accessors for wiring: those setters update `NIL.parent`
+     *   and can corrupt sentinel invariants / cause hangs. Only touch `header._left/_right`.
+     */
+    protected _header: RedBlackTreeNode<K, V>;
+    /**
+     * (Internal) Cache of the current minimum and maximum nodes.
+     * Used for fast-path insert/update when keys are monotonic or near-boundary.
+     */
+    protected _minNode: RedBlackTreeNode<K, V> | undefined;
+    protected _maxNode: RedBlackTreeNode<K, V> | undefined;
     /**
      * Get the current root node.
      * @remarks Time O(1), Space O(1)
@@ -234,25 +251,122 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
      * @remarks Time O(n), Space O(1)
      * @returns void
      */
+    /**
+     * Remove all nodes and clear internal caches.
+     * @remarks Time O(n) average, Space O(1)
+     */
     clear(): void;
     /**
-     * Insert or replace an entry using BST order and red-black fix-up.
-     * @remarks Time O(log n), Space O(1)
-     * @param keyNodeOrEntry - Key, node, or [key, value] entry to insert.
-     * @param [value]- See parameter type for details.
-     * @returns True if inserted or updated; false if ignored.
+     * (Internal) Find a node by key using a tight BST walk (no allocations).
+     *
+     * NOTE: This uses `header.parent` as the canonical root pointer.
+     * @remarks Time O(log n) average, Space O(1)
+     */
+    protected _findNodeByKey(key: K): RedBlackTreeNode<K, V> | undefined;
+    /**
+     * (Internal) In-order predecessor of a node in a BST.
+     * @remarks Time O(log n) average, Space O(1)
+     */
+    protected _predecessorOf(node: RedBlackTreeNode<K, V>): RedBlackTreeNode<K, V> | undefined;
+    /**
+     * (Internal) In-order successor of a node in a BST.
+     * @remarks Time O(log n) average, Space O(1)
+     */
+    protected _successorOf(node: RedBlackTreeNode<K, V>): RedBlackTreeNode<K, V> | undefined;
+    /**
+     * (Internal) Attach a new node directly under a known parent/side (no search).
+     *
+     * This is a performance-oriented helper used by boundary fast paths and hinted insertion.
+     * It will:
+     * - wire parent/child pointers (using accessors, so parent pointers are updated)
+     * - initialize children to NIL
+     * - mark the new node RED, then run insert fix-up
+     *
+     * Precondition: the chosen slot (parent.left/parent.right) is empty (NIL/null/undefined).
+     * @remarks Time O(log n) average, Space O(1)
+     */
+    protected _attachNewNode(parent: RedBlackTreeNode<K, V>, side: 'left' | 'right', node: RedBlackTreeNode<K, V>): void;
+    /**
+     * (Internal) a single source of truth for min/max is header._left/_right.
+     * Keep legacy _minNode/_maxNode mirrored for compatibility.
+     * @remarks Time O(1), Space O(1)
+     */
+    /**
+     * (Internal) Update min cache pointers (header._left is the canonical min pointer).
+     * @remarks Time O(1), Space O(1)
+     */
+    protected _setMinCache(node: RedBlackTreeNode<K, V> | undefined): void;
+    /**
+     * (Internal) Update max cache pointers (header._right is the canonical max pointer).
+     * @remarks Time O(1), Space O(1)
+     */
+    protected _setMaxCache(node: RedBlackTreeNode<K, V> | undefined): void;
+    /**
+     * (Internal) Core set implementation returning the affected node.
+     *
+     * Hot path goals:
+     * - Avoid double walks (search+insert): do a single traversal that either updates or inserts.
+     * - Use header min/max caches to fast-path boundary inserts.
+     * - Keep header._left/_right as canonical min/max pointers.
+     *
+     * Return value:
+     * - `{ node, created:false }` when an existing key is updated
+     * - `{ node, created:true }` when a new node is inserted
+     * - `undefined` only on unexpected internal failure.
+     * @remarks Time O(log n) average, Space O(1)
+     */
+    protected _setKVNode(key: K, nextValue?: V): {
+        node: RedBlackTreeNode<K, V>;
+        created: boolean;
+    } | undefined;
+    /**
+     * (Internal) Boolean wrapper around `_setKVNode`.
+     *
+     * Includes a map-mode update fast-path:
+     * - If `isMapMode=true` and the key already exists in `_store`, then updating the value does not
+     *   require any tree search/rotation (tree shape depends only on key).
+     * - This path is intentionally limited to `nextValue !== undefined` to preserve existing
+     *   semantics for `undefined` values.
+     * @remarks Time O(log n) average, Space O(1)
+     */
+    protected _setKV(key: K, nextValue?: V): boolean;
+    /**
+     * Insert/update using a hint node to speed up nearby insertions.
+     *
+     * close to the expected insertion position (often the previously returned node in a loop).
+     *
+     * When the hint is a good fit (sorted / nearly-sorted insertion), this can avoid most of the
+     * normal root-to-leaf search and reduce constant factors.
+     *
+     * When the hint does not match (random workloads), this will fall back to the normal set path.
+     * @remarks Time O(log n) average, Space O(1)
+     */
+    setWithHintNode(key: K, value: V, hint?: RedBlackTreeNode<K, V>): RedBlackTreeNode<K, V> | undefined;
+    /**
+     * Boolean wrapper for setWithHintNode.
+     * @remarks Time O(log n) average, Space O(1)
+     */
+    setWithHint(key: K, value: V, hint?: RedBlackTreeNode<K, V>): boolean;
+    /**
+     * Insert or update a key/value (map mode) or key-only (set mode).
+     *
+     * This method is optimized for:
+     * - monotonic inserts via min/max boundary fast paths
+     * - updates via a single-pass search (no double walk)
+     *
+     * @remarks Time O(log n) average, Space O(1)
      */
     set(keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
     /**
      * Delete a node by key/node/entry and rebalance as needed.
-     * @remarks Time O(log n), Space O(1)
-     * @param keyNodeOrEntry - Key, node, or [key, value] entry identifying the node to delete.
+     * @remarks Time O(log n) average, Space O(1)
+     * @param keyNodeEntryRawOrPredicate - Key, node, or [key, value] entry identifying the node to delete.
      * @returns Array with deletion metadata (removed node, rebalancing hint if any).
      */
-    delete(keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>[];
+    delete(keyNodeEntryRawOrPredicate: BTNRep<K, V, RedBlackTreeNode<K, V>> | NodePredicate<RedBlackTreeNode<K, V> | null>): BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>[];
     /**
      * Transform entries into a like-kind red-black tree with possibly different key/value types.
-     * @remarks Time O(n), Space O(n)
+     * @remarks Time O(n) average, Space O(n)
      * @template MK
      * @template MV
      * @template MR
@@ -262,13 +376,29 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
      * @returns A new RedBlackTree with mapped entries.
      */
     map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<RedBlackTreeOptions<MK, MV, MR>>, thisArg?: unknown): RedBlackTree<MK, MV, MR>;
+    /**
+     * (Internal) Create an empty instance of the same concrete tree type.
+     * @remarks Time O(1) average, Space O(1)
+     */
     protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<RedBlackTreeOptions<TK, TV, TR>>): this;
+    /**
+     * (Internal) Create a like-kind tree (same concrete class) populated from an iterable.
+     * @remarks Time O(m log m) average (m = iterable length), Space O(m)
+     */
     protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | RedBlackTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<RedBlackTreeOptions<TK, TV, TR>>): RedBlackTree<TK, TV, TR>;
+    /**
+     * (Internal) Set the root pointer and keep header.parent in sync.
+     * @remarks Time O(1), Space O(1)
+     */
     protected _setRoot(v: RedBlackTreeNode<K, V> | undefined): void;
+    /**
+     * (Internal) Replace a node in place while preserving its color.
+     * @remarks Time O(1) average, Space O(1)
+     */
     protected _replaceNode(oldNode: RedBlackTreeNode<K, V>, newNode: RedBlackTreeNode<K, V>): RedBlackTreeNode<K, V>;
     /**
      * (Protected) Standard BST insert followed by red-black fix-up.
-     * @remarks Time O(log n), Space O(1)
+     * @remarks Time O(log n) average, Space O(1)
      * @param node - Node to insert.
      * @returns Status string: 'CREATED' or 'UPDATED'.
      */
@@ -283,14 +413,14 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
     protected _transplant(u: RedBlackTreeNode<K, V>, v: RedBlackTreeNode<K, V> | undefined): void;
     /**
      * (Protected) Restore red-black properties after insertion (recolor/rotate).
-     * @remarks Time O(log n), Space O(1)
+     * @remarks Time O(log n) average, Space O(1)
      * @param z - Recently inserted node.
      * @returns void
      */
     protected _insertFixup(z: RedBlackTreeNode<K, V> | undefined): void;
     /**
      * (Protected) Restore red-black properties after deletion (recolor/rotate).
-     * @remarks Time O(log n), Space O(1)
+     * @remarks Time O(log n) average, Space O(1)
      * @param node - Child that replaced the deleted node (may be undefined).
      * @returns void
      */

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

@@ -0,0 +1,188 @@
+/**
+ * TreeMap (ordered map) — a restricted, native-like API backed by RedBlackTree.
+ *
+ * Design goals:
+ * - No node exposure (no node inputs/outputs)
+ * - Native Map-like surface + Java NavigableMap-like helpers
+ * - Strict default comparator (number/string/Date), otherwise require comparator
+ */
+import type { Comparator } from '../../types';
+import type { TreeMapEntryCallback, TreeMapOptions, TreeMapRangeOptions, TreeMapReduceCallback } from '../../types';
+/**
+ * An ordered Map backed by a red-black tree.
+ *
+ * - Iteration order is ascending by key.
+ * - No node exposure: all APIs use keys/values only.
+ */
+export declare class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[K, V | undefined]> {
+    #private;
+    /**
+     * Create a TreeMap from an iterable of `[key, value]` entries or raw elements.
+     *
+     * @param entries - Iterable of `[key, value]` tuples, or raw elements if `toEntryFn` is provided.
+     * @param options - Configuration options including optional `toEntryFn` to transform raw elements.
+     * @throws {TypeError} If any entry is not a 2-tuple-like value (when no toEntryFn), or when using
+     * the default comparator and encountering unsupported/invalid keys (e.g. `NaN`, invalid `Date`).
+     * @example
+     * // Standard usage with entries
+     * const map = new TreeMap([['a', 1], ['b', 2]]);
+     *
+     * // Using toEntryFn to transform raw objects
+     * const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+     * const map = new TreeMap<number, User, User>(users, { toEntryFn: u => [u.id, u] });
+     */
+    constructor(entries?: Iterable<R> | Iterable<[K, V | undefined]>, options?: TreeMapOptions<K, V, R>);
+    /**
+     * Create the strict default comparator.
+     *
+     * Supports:
+     * - `number` (rejects `NaN`; treats `-0` and `0` as equal)
+     * - `string`
+     * - `Date` (orders by `getTime()`, rejects invalid dates)
+     *
+     * For other key types, a custom comparator must be provided.
+     */
+    static createDefaultComparator<K>(): Comparator<K>;
+    private _validateKey;
+    /**
+     * Number of entries in the map.
+     */
+    get size(): number;
+    /**
+     * Whether the map is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Set or overwrite a value for a key.
+     * @remarks Expected time O(log n)
+     */
+    set(key: K, value: V | undefined): this;
+    /**
+     * Get the value under a key.
+     * @remarks Expected time O(log n)
+     */
+    get(key: K): V | undefined;
+    /**
+     * Test whether a key exists.
+     * @remarks Expected time O(log n)
+     */
+    has(key: K): boolean;
+    /**
+     * Delete a key.
+     * @returns `true` if the key existed; otherwise `false`.
+     * @remarks Expected time O(log n)
+     */
+    delete(key: K): boolean;
+    /**
+     * Remove all entries.
+     */
+    clear(): void;
+    /**
+     * Iterate over keys in ascending order.
+     */
+    keys(): IterableIterator<K>;
+    private _entryFromKey;
+    /**
+     * Iterate over values in ascending key order.
+     *
+     * Note: values may be `undefined` (TreeMap allows storing `undefined`, like native `Map`).
+     */
+    values(): IterableIterator<V | undefined>;
+    /**
+     * Iterate over `[key, value]` entries in ascending key order.
+     *
+     * Note: values may be `undefined`.
+     */
+    entries(): IterableIterator<[K, V | undefined]>;
+    [Symbol.iterator](): IterableIterator<[K, V | undefined]>;
+    /**
+     * Visit each entry in ascending key order.
+     *
+     * Note: callback value may be `undefined`.
+     */
+    forEach(cb: (value: V | undefined, key: K, map: TreeMap<K, V>) => void, thisArg?: any): 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)
+     */
+    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)
+     */
+    filter(callbackfn: TreeMapEntryCallback<K, V, boolean, TreeMap<K, V>>, thisArg?: unknown): TreeMap<K, V>;
+    /**
+     * Reduce entries into a single accumulator.
+     * @remarks Time O(n), Space O(1)
+     */
+    reduce<A>(callbackfn: TreeMapReduceCallback<K, V, A, TreeMap<K, V>>, initialValue: A): A;
+    /**
+     * Test whether all entries satisfy a predicate.
+     * @remarks Time O(n), Space O(1)
+     */
+    every(callbackfn: TreeMapEntryCallback<K, V, boolean, TreeMap<K, V>>, thisArg?: unknown): boolean;
+    /**
+     * Test whether any entry satisfies a predicate.
+     * @remarks Time O(n), Space O(1)
+     */
+    some(callbackfn: TreeMapEntryCallback<K, V, boolean, TreeMap<K, V>>, thisArg?: unknown): boolean;
+    /**
+     * Find the first entry that satisfies a predicate.
+     * @returns The first matching `[key, value]` tuple, or `undefined`.
+     * @remarks Time O(n), Space O(1)
+     */
+    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)
+     */
+    toArray(): Array<[K, V | undefined]>;
+    /**
+     * Print a human-friendly representation.
+     * @remarks Time O(n), Space O(n)
+     */
+    print(): void;
+    /**
+     * Smallest entry by key.
+     */
+    first(): [K, V | undefined] | undefined;
+    /**
+     * Largest entry by key.
+     */
+    last(): [K, V | undefined] | undefined;
+    /**
+     * Remove and return the smallest entry.
+     */
+    pollFirst(): [K, V | undefined] | undefined;
+    /**
+     * Remove and return the largest entry.
+     */
+    pollLast(): [K, V | undefined] | undefined;
+    /**
+     * Smallest entry whose key is >= the given key.
+     */
+    ceiling(key: K): [K, V | undefined] | undefined;
+    /**
+     * Largest entry whose key is <= the given key.
+     */
+    floor(key: K): [K, V | undefined] | undefined;
+    /**
+     * Smallest entry whose key is > the given key.
+     */
+    higher(key: K): [K, V | undefined] | undefined;
+    /**
+     * Largest entry whose key is < the given key.
+     */
+    lower(key: K): [K, V | undefined] | undefined;
+    /**
+     * Return all entries in a given key range.
+     *
+     * @param range `[low, high]`
+     * @param options Inclusive/exclusive bounds (defaults to inclusive).
+     */
+    rangeSearch(range: [K, K], options?: TreeMapRangeOptions): Array<[K, V | undefined]>;
+}