binary-tree-typed 2.5.2 → 2.6.0

package/src/data-structures/binary-tree/tree-set.ts

@@ -241,6 +241,41 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -432,6 +467,41 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -473,8 +543,11 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
   }
 
   /**
-   * Test whether a key exists.
-   * @remarks Expected time O(log n)
+   * 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.
+  
    
    
    
@@ -502,6 +575,25 @@ export 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[] {
+    const results: boolean[] = [];
+    for (const key of keys) {
+      this._validateKey(key);
+      results.push(this.#core.set(key, undefined));
+    }
+    return results;
+  }
+
+  /**
+   * Test whether a key exists.
+   * @remarks Expected time O(log n)
+   
    
    
    
@@ -644,22 +736,6 @@ export 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 {
-    this._validateKey(key);
-    return this.#core.has(key);
-  }
-
-  /**
-   * Delete a key.
-   * @returns `true` if the key existed; otherwise `false`.
-   * @remarks Expected time O(log n)
    
    
    
@@ -721,6 +797,22 @@ export 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 {
+    this._validateKey(key);
+    return this.#core.has(key);
+  }
+
+  /**
+   * Delete a key.
+   * @returns `true` if the key existed; otherwise `false`.
+   * @remarks Expected time O(log n)
    
    
    
@@ -829,22 +921,6 @@ export 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 {
-    this._validateKey(key);
-    const res = this.#core.delete(key);
-    return Array.isArray(res) && res.length > 0 && !!res[0]?.deleted;
-  }
-
-  /**
-   * Remove all keys.
    
    
    
@@ -941,6 +1017,39 @@ export 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 {
+    this._validateKey(key);
+    return this.#core.delete(key);
+  }
+
+  /**
+   * 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 {
+    let deleted = false;
+    let index = 0;
+    for (const key of this) {
+      if (predicate(key, index++, this)) {
+        this.delete(key);
+        deleted = true;
+      }
+    }
+    return deleted;
+  }
+
+  /**
+   * Remove all keys.
    
    
    
@@ -1003,18 +1112,6 @@ export 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 {
-    this.#core.clear();
-  }
-
-  /**
-   * Iterate over keys in ascending order.
    
    
    
@@ -1146,6 +1243,26 @@ export 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 {
+    this.#core.clear();
+  }
+
+  /**
+   * Iterate over keys in ascending order.
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -1173,19 +1290,6 @@ export 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> {
-    return this.#core.keys();
-  }
-
-  /**
-   * Iterate over values in ascending order.
-   *
-   * Note: for Set-like containers, `values()` is the same as `keys()`.
    
    
    
@@ -1345,20 +1449,18 @@ export 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];
+ * // Get sorted keys
+ *  const ts = new TreeSet<number>([30, 10, 20]);
+ *       console.log([...ts.keys()]); // [10, 20, 30];
    */
-  values(): IterableIterator<K> {
-    return this.keys();
+  keys(): IterableIterator<K> {
+    return this.#core.keys();
   }
 
   /**
-   * Iterate over `[value, value]` pairs (native Set convention).
+   * Iterate over values in ascending order.
    *
-   * Note: TreeSet stores only keys internally; `[k, k]` is created on-the-fly during iteration.
-   
-   
+   * Note: for Set-like containers, `values()` is the same as `keys()`.
    
    
    
@@ -1515,23 +1617,6 @@ export 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]> {
-    for (const k of this.keys()) yield [k, k];
-  }
-
-  [Symbol.iterator](): IterableIterator<K> {
-    return this.keys();
-  }
-
-  /**
-   * Visit each value in ascending order.
-   *
-   * Callback follows native Set convention: `(value, value2, set)`.
    
    
    
@@ -1569,6 +1654,19 @@ export 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> {
+    return this.keys();
+  }
+
+  /**
+   * Iterate over `[value, value]` pairs (native Set convention).
+   *
+   * Note: TreeSet stores only keys internally; `[k, k]` is created on-the-fly during iteration.
    
    
    
@@ -1690,38 +1788,6 @@ export 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 {
-    for (const k of this) cb.call(thisArg, k, k, this);
-  }
-
-  /**
-   * 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)
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
    
    
    
@@ -1794,6 +1860,23 @@ export 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]> {
+    for (const k of this.keys()) yield [k, k];
+  }
+
+  [Symbol.iterator](): IterableIterator<K> {
+    return this.keys();
+  }
+
+  /**
+   * Visit each value in ascending order.
+   *
+   * Callback follows native Set convention: `(value, value2, set)`.
    
    
    
@@ -1864,31 +1947,6 @@ export 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> {
-    const out = new TreeSet<MK>([], options as TreeSetOptions<MK>);
-    let index = 0;
-    for (const v of this) {
-      const mk = thisArg === undefined
-        ? callbackfn(v, index++, this)
-        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => MK).call(thisArg, v, index++, this);
-      out.add(mk);
-    }
-    return out;
-  }
-
-  /**
-   * Create a new TreeSet containing only values that satisfy the predicate.
-   * @remarks Time O(n log n) expected, Space O(n)
    
    
    
@@ -2012,6 +2070,22 @@ export 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 {
+    for (const k of this) cb.call(thisArg, k, k, this);
+  }
+
+  /**
+   * 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)
    
    
    
@@ -2047,27 +2121,6 @@ export 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> {
-    const out = new TreeSet<K>([], { comparator: this.#userComparator });
-    let index = 0;
-    for (const v of this) {
-      const ok = thisArg === undefined
-        ? callbackfn(v, index++, this)
-        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => boolean).call(thisArg, v, index++, this);
-      if (ok) out.add(v);
-    }
-    return out;
-  }
-
-  /**
-   * Reduce values into a single accumulator.
-   * @remarks Time O(n), Space O(1)
    
    
    
@@ -2227,29 +2280,30 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
     * @example
- * // Aggregate
+ * // Transform
  *  const ts = new TreeSet<number>([1, 2, 3]);
- *       const sum = ts.reduce((acc, k) => acc + k, 0);
- *       console.log(sum); // 6;
+ *       const doubled = ts.map(k => k * 2);
+ *       console.log([...doubled]); // [2, 4, 6];
    */
-  reduce<A>(callbackfn: TreeSetReduceCallback<K, A, TreeSet<K>>, initialValue: A): A {
-    let acc = initialValue;
+  map<MK>(
+    callbackfn: TreeSetElementCallback<K, MK, TreeSet<K>>,
+    options: Omit<TreeSetOptions<MK>, 'toElementFn'> & { comparator?: (a: MK, b: MK) => number } = {},
+    thisArg?: unknown
+  ): TreeSet<MK> {
+    const out = new TreeSet<MK>([], options as TreeSetOptions<MK>);
     let index = 0;
-    for (const v of this) acc = callbackfn(acc, v, index++, this);
-    return acc;
+    for (const v of this) {
+      const mk = thisArg === undefined
+        ? callbackfn(v, index++, this)
+        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => MK).call(thisArg, v, index++, this);
+      out.add(mk);
+    }
+    return out;
   }
 
   /**
-   * Test whether all values satisfy a predicate.
-   * @remarks Time O(n), Space O(1)
-   
-   
-   
-   
-   
-   
-   
-   
+   * Create a new TreeSet containing only values that satisfy the predicate.
+   * @remarks Time O(n log n) expected, Space O(n)
    
    
    
@@ -2398,25 +2452,6 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
-    * @example
- * // Test all
- *  const ts = new TreeSet<number>([2, 4, 6]);
- *       console.log(ts.every(k => k > 0)); // true;
-   */
-  every(callbackfn: TreeSetElementCallback<K, boolean, TreeSet<K>>, thisArg?: unknown): boolean {
-    let index = 0;
-    for (const v of this) {
-      const ok = thisArg === undefined
-        ? callbackfn(v, index++, this)
-        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => boolean).call(thisArg, v, index++, this);
-      if (!ok) return false;
-    }
-    return true;
-  }
-
-  /**
-   * Test whether any value satisfies a predicate.
-   * @remarks Time O(n), Space O(1)
    
    
    
@@ -2462,6 +2497,27 @@ export 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> {
+    const out = new TreeSet<K>([], { comparator: this.#userComparator });
+    let index = 0;
+    for (const v of this) {
+      const ok = thisArg === undefined
+        ? callbackfn(v, index++, this)
+        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => boolean).call(thisArg, v, index++, this);
+      if (ok) out.add(v);
+    }
+    return out;
+  }
+
+  /**
+   * Reduce values into a single accumulator.
+   * @remarks Time O(n), Space O(1)
    
    
    
@@ -2573,25 +2629,6 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
-    * @example
- * // Test any
- *  const ts = new TreeSet<number>([1, 3, 5]);
- *       console.log(ts.some(k => k === 3)); // true;
-   */
-  some(callbackfn: TreeSetElementCallback<K, boolean, TreeSet<K>>, thisArg?: unknown): boolean {
-    let index = 0;
-    for (const v of this) {
-      const ok = thisArg === undefined
-        ? callbackfn(v, index++, this)
-        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => boolean).call(thisArg, v, index++, this);
-      if (ok) return true;
-    }
-    return false;
-  }
-
-  /**
-   * Find the first value that satisfies a predicate.
-   * @remarks Time O(n), Space O(1)
    
    
    
@@ -2674,6 +2711,22 @@ export 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 {
+    let acc = initialValue;
+    let index = 0;
+    for (const v of this) acc = callbackfn(acc, v, index++, this);
+    return acc;
+  }
+
+  /**
+   * Test whether all values satisfy a predicate.
+   * @remarks Time O(n), Space O(1)
    
    
    
@@ -2748,26 +2801,6 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
-    * @example
- * // Find entry
- *  const ts = new TreeSet<number>([1, 2, 3]);
- *       const found = ts.find(k => k === 2);
- *       console.log(found); // 2;
-   */
-  find(callbackfn: TreeSetElementCallback<K, boolean, TreeSet<K>>, thisArg?: unknown): K | undefined {
-    let index = 0;
-    for (const v of this) {
-      const ok = thisArg === undefined
-        ? callbackfn(v, index++, this)
-        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => boolean).call(thisArg, v, index++, this);
-      if (ok) return v;
-    }
-    return undefined;
-  }
-
-  /**
-   * Materialize the set into an array of keys.
-   * @remarks Time O(n), Space O(n)
    
    
    
@@ -2885,6 +2918,25 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+    * @example
+ * // Test all
+ *  const ts = new TreeSet<number>([2, 4, 6]);
+ *       console.log(ts.every(k => k > 0)); // true;
+   */
+  every(callbackfn: TreeSetElementCallback<K, boolean, TreeSet<K>>, thisArg?: unknown): boolean {
+    let index = 0;
+    for (const v of this) {
+      const ok = thisArg === undefined
+        ? callbackfn(v, index++, this)
+        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => boolean).call(thisArg, v, index++, this);
+      if (!ok) return false;
+    }
+    return true;
+  }
+
+  /**
+   * Test whether any value satisfies a predicate.
+   * @remarks Time O(n), Space O(1)
    
    
    
@@ -2926,18 +2978,626 @@ export 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[] {
-    return [...this];
-  }
-
-  /**
-   * Print a human-friendly representation.
-   * @remarks Time O(n), Space O(n)
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Test any
+ *  const ts = new TreeSet<number>([1, 3, 5]);
+ *       console.log(ts.some(k => k === 3)); // true;
+   */
+  some(callbackfn: TreeSetElementCallback<K, boolean, TreeSet<K>>, thisArg?: unknown): boolean {
+    let index = 0;
+    for (const v of this) {
+      const ok = thisArg === undefined
+        ? callbackfn(v, index++, this)
+        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => boolean).call(thisArg, v, index++, this);
+      if (ok) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Find the first value that satisfies a predicate.
+   * @remarks Time O(n), Space O(1)
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Find entry
+ *  const ts = new TreeSet<number>([1, 2, 3]);
+ *       const found = ts.find(k => k === 2);
+ *       console.log(found); // 2;
+   */
+  find(callbackfn: TreeSetElementCallback<K, boolean, TreeSet<K>>, thisArg?: unknown): K | undefined {
+    let index = 0;
+    for (const v of this) {
+      const ok = thisArg === undefined
+        ? callbackfn(v, index++, this)
+        : (callbackfn as (this: unknown, v: K, i: number, self: TreeSet<K>) => boolean).call(thisArg, v, index++, this);
+      if (ok) return v;
+    }
+    return undefined;
+  }
+
+  /**
+   * Materialize the set into an array of keys.
+   * @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[] {
+    return [...this];
+  }
+
+  /**
+   * Print a human-friendly representation.
+   * @remarks Time O(n), Space O(n)
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -3137,6 +3797,13 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -3206,6 +3873,13 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -3253,6 +3927,13 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -3305,6 +3986,13 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -3442,6 +4130,34 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -3600,6 +4316,34 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -3750,6 +4494,34 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -3898,6 +4670,34 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -4049,6 +4849,34 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -4150,8 +4978,22 @@ export 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 }
@@ -4331,6 +5173,173 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Deep clone
+ *  const ts = new TreeSet<number>([1, 2, 3]);
+ *       const copy = ts.clone();
+ *       copy.delete(1);
+ *       console.log(ts.has(1)); // true;
+   */
+  // ---- ES2025 Set-like operations ----
+
+  /**
+   * 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> {
+    const result = this.clone();
+    for (const key of other) result.add(key);
+    return result;
+  }
+
+  /**
+   * 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> {
+    const otherSet = other instanceof TreeSet || other instanceof Set ? other : new Set(other);
+    const result = new TreeSet<K>([], { comparator: this.#isDefaultComparator ? undefined : this.#userComparator });
+    for (const key of this) {
+      if (otherSet.has(key)) result.add(key);
+    }
+    return result;
+  }
+
+  /**
+   * 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> {
+    const otherSet = other instanceof TreeSet || other instanceof Set ? other : new Set(other);
+    const result = new TreeSet<K>([], { comparator: this.#isDefaultComparator ? undefined : this.#userComparator });
+    for (const key of this) {
+      if (!otherSet.has(key)) result.add(key);
+    }
+    return result;
+  }
+
+  /**
+   * 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> {
+    const otherSet = other instanceof TreeSet || other instanceof Set ? other : new Set(other);
+    const result = new TreeSet<K>([], { comparator: this.#isDefaultComparator ? undefined : this.#userComparator });
+    for (const key of this) {
+      if (!otherSet.has(key)) result.add(key);
+    }
+    for (const key of otherSet) {
+      if (!this.has(key)) result.add(key);
+    }
+    return result;
+  }
+
+  /**
+   * 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 {
+    const otherSet = other instanceof TreeSet || other instanceof Set ? other : new Set(other);
+    for (const key of this) {
+      if (!otherSet.has(key)) return false;
+    }
+    return true;
+  }
+
+  /**
+   * 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 {
+    for (const key of other) {
+      if (!this.has(key)) return false;
+    }
+    return true;
+  }
+
+  /**
+   * 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 {
+    const otherSet = other instanceof TreeSet || other instanceof Set ? other : new Set(other);
+    for (const key of this) {
+      if (otherSet.has(key)) return false;
+    }
+    return true;
+  }
+
+    /**
+   * Deep copy
+  
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Deep clone
  *  const ts = new TreeSet<number>([1, 2, 3]);