max-priority-queue-typed 2.5.2 → 2.6.0

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

@@ -212,15 +212,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Check empty
-   *  console.log(new TreeSet().isEmpty()); // true;
-     */
-    isEmpty(): boolean;
-    private _validateKey;
-    /**
-     * Add a key to the set (no-op if already present).
-     * @remarks Expected time O(log n)
      
      
      
@@ -256,6 +247,15 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Check empty
+   *  console.log(new TreeSet().isEmpty()); // true;
+     */
+    isEmpty(): boolean;
+    private _validateKey;
+    /**
+     * Add a key to the set (no-op if already present).
+     * @remarks Expected time O(log n)
      
      
      
@@ -382,22 +382,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Unique tags with sorted order
-   *  const tags = new TreeSet<string>(['javascript', 'typescript', 'react', 'typescript', 'node']);
-   *
-   *     // Duplicates removed, sorted alphabetically
-   *     console.log([...tags]); // ['javascript', 'node', 'react', 'typescript'];
-   *     console.log(tags.size); // 4;
-   *
-   *     tags.add('angular');
-   *     console.log(tags.first()); // 'angular';
-   *     console.log(tags.last()); // 'typescript';
-     */
-    add(key: K): this;
-    /**
-     * Test whether a key exists.
-     * @remarks Expected time O(log n)
      
      
      
@@ -468,6 +452,25 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Unique tags with sorted order
+   *  const tags = new TreeSet<string>(['javascript', 'typescript', 'react', 'typescript', 'node']);
+   *
+   *     // Duplicates removed, sorted alphabetically
+   *     console.log([...tags]); // ['javascript', 'node', 'react', 'typescript'];
+   *     console.log(tags.size); // 4;
+   *
+   *     tags.add('angular');
+   *     console.log(tags.first()); // 'angular';
+   *     console.log(tags.last()); // 'typescript';
+     */
+    add(key: K): this;
+    /**
+     * Add multiple keys at once.
+     * @remarks Expected time O(m log n), where m is the number of keys.
+     * @param keys - Iterable of keys to add.
+     * @returns Array of booleans indicating whether each key was newly added.
+    
      
      
      
@@ -495,6 +498,16 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Add multiple keys
+   *  const ts = new TreeSet<number>();
+   *     ts.addMany([5, 3, 7, 1, 9]);
+   *     console.log(ts.size); // 5;
+     */
+    addMany(keys: Iterable<K>): boolean[];
+    /**
+     * Test whether a key exists.
+     * @remarks Expected time O(log n)
      
      
      
@@ -567,18 +580,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Checking membership in a sorted collection
-   *  const allowed = new TreeSet<string>(['admin', 'editor', 'viewer']);
-   *
-   *     console.log(allowed.has('admin')); // true;
-   *     console.log(allowed.has('guest')); // false;
-     */
-    has(key: K): boolean;
-    /**
-     * Delete a key.
-     * @returns `true` if the key existed; otherwise `false`.
-     * @remarks Expected time O(log n)
      
      
      
@@ -711,6 +712,27 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Checking membership in a sorted collection
+   *  const allowed = new TreeSet<string>(['admin', 'editor', 'viewer']);
+   *
+   *     console.log(allowed.has('admin')); // true;
+   *     console.log(allowed.has('guest')); // false;
+     */
+    has(key: K): boolean;
+    /**
+     * Delete a key.
+     * @returns `true` if the key existed; otherwise `false`.
+     * @remarks Expected time O(log n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -748,17 +770,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Removing elements while maintaining order
-   *  const nums = new TreeSet<number>([1, 3, 5, 7, 9]);
-   *
-   *     console.log(nums.delete(5)); // true;
-   *     console.log(nums.delete(5)); // false; // already gone
-   *     console.log([...nums]); // [1, 3, 7, 9];
-     */
-    delete(key: K): boolean;
-    /**
-     * Remove all keys.
      
      
      
@@ -918,14 +929,23 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
       * @example
-   * // Remove all
-   *  const ts = new TreeSet<number>([1, 2]);
-   *       ts.clear();
-   *       console.log(ts.isEmpty()); // true;
+   * // Removing elements while maintaining order
+   *  const nums = new TreeSet<number>([1, 3, 5, 7, 9]);
+   *
+   *     console.log(nums.delete(5)); // true;
+   *     console.log(nums.delete(5)); // false; // already gone
+   *     console.log([...nums]); // [1, 3, 7, 9];
      */
-    clear(): void;
+    delete(key: K): boolean;
     /**
-     * Iterate over keys in ascending order.
+     * Delete all keys matching a predicate.
+     * @remarks Time O(N), Space O(N)
+     * @param predicate - Function (key, index, set) → boolean; return true to delete.
+     * @returns True if at least one key was deleted.
+     */
+    deleteWhere(predicate: (key: K, index: number, set: this) => boolean): boolean;
+    /**
+     * Remove all keys.
      
      
      
@@ -1084,16 +1104,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Get sorted keys
-   *  const ts = new TreeSet<number>([30, 10, 20]);
-   *       console.log([...ts.keys()]); // [10, 20, 30];
-     */
-    keys(): IterableIterator<K>;
-    /**
-     * Iterate over values in ascending order.
-     *
-     * Note: for Set-like containers, `values()` is the same as `keys()`.
      
      
      
@@ -1129,6 +1139,15 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Remove all
+   *  const ts = new TreeSet<number>([1, 2]);
+   *       ts.clear();
+   *       console.log(ts.isEmpty()); // true;
+     */
+    clear(): void;
+    /**
+     * Iterate over keys in ascending order.
      
      
      
@@ -1252,16 +1271,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Get values (same as keys for Set)
-   *  const ts = new TreeSet<number>([2, 1, 3]);
-   *       console.log([...ts.values()]); // [1, 2, 3];
-     */
-    values(): IterableIterator<K>;
-    /**
-     * Iterate over `[value, value]` pairs (native Set convention).
-     *
-     * Note: TreeSet stores only keys internally; `[k, k]` is created on-the-fly during iteration.
      
      
      
@@ -1332,6 +1341,16 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Get sorted keys
+   *  const ts = new TreeSet<number>([30, 10, 20]);
+   *       console.log([...ts.keys()]); // [10, 20, 30];
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Iterate over values in ascending order.
+     *
+     * Note: for Set-like containers, `values()` is the same as `keys()`.
      
      
      
@@ -1420,17 +1439,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Iterate entries
-   *  const ts = new TreeSet<number>([3, 1, 2]);
-   *       console.log([...ts.entries()].map(([k]) => k)); // [1, 2, 3];
-     */
-    entries(): IterableIterator<[K, K]>;
-    [Symbol.iterator](): IterableIterator<K>;
-    /**
-     * Visit each value in ascending order.
-     *
-     * Callback follows native Set convention: `(value, value2, set)`.
      
      
      
@@ -1536,6 +1544,16 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Get values (same as keys for Set)
+   *  const ts = new TreeSet<number>([2, 1, 3]);
+   *       console.log([...ts.values()]); // [1, 2, 3];
+     */
+    values(): IterableIterator<K>;
+    /**
+     * Iterate over `[value, value]` pairs (native Set convention).
+     *
+     * Note: TreeSet stores only keys internally; `[k, k]` is created on-the-fly during iteration.
      
      
      
@@ -1589,19 +1607,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Execute for each
-   *  const ts = new TreeSet<number>([3, 1, 2]);
-   *       const keys: number[] = [];
-   *       ts.forEach(k => keys.push(k));
-   *       console.log(keys); // [1, 2, 3];
-     */
-    forEach(cb: (value: K, value2: K, set: TreeSet<K>) => void, thisArg?: unknown): void;
-    /**
-     * Create a new TreeSet by mapping each value to a new key.
-     *
-     * This mirrors `RedBlackTree.map`: mapping produces a new ordered container.
-     * @remarks Time O(n log n) expected, Space O(n)
      
      
      
@@ -1742,6 +1747,17 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Iterate entries
+   *  const ts = new TreeSet<number>([3, 1, 2]);
+   *       console.log([...ts.entries()].map(([k]) => k)); // [1, 2, 3];
+     */
+    entries(): IterableIterator<[K, K]>;
+    [Symbol.iterator](): IterableIterator<K>;
+    /**
+     * Visit each value in ascending order.
+     *
+     * Callback follows native Set convention: `(value, value2, set)`.
      
      
      
@@ -1760,18 +1776,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Transform
-   *  const ts = new TreeSet<number>([1, 2, 3]);
-   *       const doubled = ts.map(k => k * 2);
-   *       console.log([...doubled]); // [2, 4, 6];
-     */
-    map<MK>(callbackfn: TreeSetElementCallback<K, MK, TreeSet<K>>, options?: Omit<TreeSetOptions<MK>, 'toElementFn'> & {
-        comparator?: (a: MK, b: MK) => number;
-    }, thisArg?: unknown): TreeSet<MK>;
-    /**
-     * Create a new TreeSet containing only values that satisfy the predicate.
-     * @remarks Time O(n log n) expected, Space O(n)
      
      
      
@@ -1930,16 +1934,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Filter
-   *  const ts = new TreeSet<number>([1, 2, 3, 4, 5]);
-   *       const evens = ts.filter(k => k % 2 === 0);
-   *       console.log([...evens]); // [2, 4];
-     */
-    filter(callbackfn: TreeSetElementCallback<K, boolean, TreeSet<K>>, thisArg?: unknown): TreeSet<K>;
-    /**
-     * Reduce values into a single accumulator.
-     * @remarks Time O(n), Space O(1)
      
      
      
@@ -1957,6 +1951,19 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Execute for each
+   *  const ts = new TreeSet<number>([3, 1, 2]);
+   *       const keys: number[] = [];
+   *       ts.forEach(k => keys.push(k));
+   *       console.log(keys); // [1, 2, 3];
+     */
+    forEach(cb: (value: K, value2: K, set: TreeSet<K>) => void, thisArg?: unknown): void;
+    /**
+     * Create a new TreeSet by mapping each value to a new key.
+     *
+     * This mirrors `RedBlackTree.map`: mapping produces a new ordered container.
+     * @remarks Time O(n log n) expected, Space O(n)
      
      
      
@@ -2098,16 +2105,6 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Aggregate
-   *  const ts = new TreeSet<number>([1, 2, 3]);
-   *       const sum = ts.reduce((acc, k) => acc + k, 0);
-   *       console.log(sum); // 6;
-     */
-    reduce<A>(callbackfn: TreeSetReduceCallback<K, A, TreeSet<K>>, initialValue: A): A;
-    /**
-     * Test whether all values satisfy a predicate.
-     * @remarks Time O(n), Space O(1)
      
      
      
@@ -2160,6 +2157,18 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+      * @example
+   * // Transform
+   *  const ts = new TreeSet<number>([1, 2, 3]);
+   *       const doubled = ts.map(k => k * 2);
+   *       console.log([...doubled]); // [2, 4, 6];
+     */
+    map<MK>(callbackfn: TreeSetElementCallback<K, MK, TreeSet<K>>, options?: Omit<TreeSetOptions<MK>, 'toElementFn'> & {
+        comparator?: (a: MK, b: MK) => number;
+    }, thisArg?: unknown): TreeSet<MK>;
+    /**
+     * Create a new TreeSet containing only values that satisfy the predicate.
+     * @remarks Time O(n log n) expected, Space O(n)
      
      
      
@@ -2264,7 +2273,500 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Filter
+   *  const ts = new TreeSet<number>([1, 2, 3, 4, 5]);
+   *       const evens = ts.filter(k => k % 2 === 0);
+   *       console.log([...evens]); // [2, 4];
+     */
+    filter(callbackfn: TreeSetElementCallback<K, boolean, TreeSet<K>>, thisArg?: unknown): TreeSet<K>;
+    /**
+     * Reduce values into a single accumulator.
+     * @remarks Time O(n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Aggregate
+   *  const ts = new TreeSet<number>([1, 2, 3]);
+   *       const sum = ts.reduce((acc, k) => acc + k, 0);
+   *       console.log(sum); // 6;
+     */
+    reduce<A>(callbackfn: TreeSetReduceCallback<K, A, TreeSet<K>>, initialValue: A): A;
+    /**
+     * Test whether all values satisfy a predicate.
+     * @remarks Time O(n), Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
    * // Test all
    *  const ts = new TreeSet<number>([2, 4, 6]);
    *       console.log(ts.every(k => k > 0)); // true;
@@ -2408,6 +2910,41 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -2573,6 +3110,41 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -2762,15 +3334,85 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
-      * @example
-   * // Convert to array
-   *  const ts = new TreeSet<number>([3, 1, 2]);
-   *       console.log(ts.toArray()); // [1, 2, 3];
-     */
-    toArray(): K[];
-    /**
-     * Print a human-friendly representation.
-     * @remarks Time O(n), Space O(n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Convert to array
+   *  const ts = new TreeSet<number>([3, 1, 2]);
+   *       console.log(ts.toArray()); // [1, 2, 3];
+     */
+    toArray(): K[];
+    /**
+     * Print a human-friendly representation.
+     * @remarks Time O(n), Space O(n)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -2964,6 +3606,13 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3030,6 +3679,13 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3074,6 +3730,13 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3120,6 +3783,13 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3251,6 +3921,34 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3405,6 +4103,34 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3551,6 +4277,34 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3695,6 +4449,34 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3842,6 +4624,34 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -3915,8 +4725,22 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      * Returns elements 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 TreeSet<number>(
    *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
    *         { enableOrderStatistic: true }
@@ -4072,6 +4896,31 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
      
      
      
@@ -4100,5 +4949,93 @@ export declare class TreeSet<K = any, R = K> implements Iterable<K> {
    *       copy.delete(1);
    *       console.log(ts.has(1)); // true;
      */
+    /**
+     * Return a new TreeSet containing all elements from both sets.
+     * @remarks When both sets share the same comparator, uses O(n+m) merge. Otherwise O(m log n).
+     * @param other - Any iterable of keys.
+     * @returns A new TreeSet.
+      * @example
+   * // Merge two sets
+   *  console.log([...a.union(b)]); // [1, 2, 3, 4, 5, 6, 7];
+     */
+    union(other: Iterable<K>): TreeSet<K>;
+    /**
+     * Return a new TreeSet containing only elements present in both sets.
+     * @remarks Time O(n+m) with ordered merge when possible, otherwise O(n log m).
+     * @param other - Any iterable of keys (converted to Set for fast lookup if not a TreeSet).
+     * @returns A new TreeSet.
+      * @example
+   * // Find common elements
+   *  console.log([...a.intersection(b)]); // [3, 4, 5];
+     */
+    intersection(other: Iterable<K>): TreeSet<K>;
+    /**
+     * Return a new TreeSet containing elements in this set but not in the other.
+     * @remarks Time O(n+m) with ordered merge when possible, otherwise O(n log m).
+     * @param other - Any iterable of keys.
+     * @returns A new TreeSet.
+      * @example
+   * // Find exclusive elements
+   *  console.log([...a.difference(b)]); // [1, 2];
+     */
+    difference(other: Iterable<K>): TreeSet<K>;
+    /**
+     * Return a new TreeSet containing elements in either set but not both.
+     * @remarks Time O(n+m).
+     * @param other - Any iterable of keys.
+     * @returns A new TreeSet.
+      * @example
+   * // Find symmetric difference
+   *  console.log([...a.symmetricDifference(b)]); // [1, 2, 6, 7];
+     */
+    symmetricDifference(other: Iterable<K>): TreeSet<K>;
+    /**
+     * Check whether every element in this set is also in the other.
+     * @remarks Time O(n).
+     * @param other - Any iterable of keys (converted to Set for fast lookup if not a TreeSet).
+     * @returns `true` if this is a subset of other.
+      * @example
+   * // Check subset
+   *  console.log(new TreeSet([3, 4]).isSubsetOf(a)); // true;
+     */
+    isSubsetOf(other: Iterable<K>): boolean;
+    /**
+     * Check whether every element in the other set is also in this set.
+     * @remarks Time O(m).
+     * @param other - Any iterable of keys.
+     * @returns `true` if this is a superset of other.
+      * @example
+   * // Check superset
+   *  console.log(a.isSupersetOf(new TreeSet([2, 3]))); // true;
+     */
+    isSupersetOf(other: Iterable<K>): boolean;
+    /**
+     * Check whether this set and the other share no common elements.
+     * @remarks Time O(min(n,m)), can short-circuit on first overlap.
+     * @param other - Any iterable of keys (converted to Set for fast lookup if not a TreeSet).
+     * @returns `true` if sets are disjoint.
+      * @example
+   * // Check disjoint
+   *  console.log(a.isDisjointFrom(new TreeSet([8, 9]))); // true;
+     */
+    isDisjointFrom(other: Iterable<K>): boolean;
+    /**
+   * Deep copy
+  
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Deep clone
+ *  const ts = new TreeSet<number>([1, 2, 3]);
+ *       const copy = ts.clone();
+ *       copy.delete(1);
+ *       console.log(ts.has(1)); // true;
+   */
     clone(): TreeSet<K>;
 }