data-structure-typed 2.5.3 → 2.6.1

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

@@ -6,9 +6,13 @@
  * - Native Set-like surface + Java NavigableSet-like helpers
  * - Strict default comparator (number/string/Date), otherwise require comparator
  */
-
-import type { Comparator } from '../../types';
-import type { TreeSetElementCallback, TreeSetOptions, TreeSetRangeOptions, TreeSetReduceCallback } from '../../types';
+import type {
+  Comparator,
+  TreeSetElementCallback,
+  TreeSetOptions,
+  TreeSetRangeOptions,
+  TreeSetReduceCallback
+} from '../../types';
 import { ERR, raise } from '../../common';
 import { RedBlackTree } from './red-black-tree';
 
@@ -48,16 +52,25 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
     const toElementFn = options.toElementFn;
     const comparator = options.comparator ?? TreeSet.createDefaultComparator<K>();
     this.#isDefaultComparator = options.comparator === undefined;
-
     // RedBlackTree expects an iterable of keys/entries/nodes/raws; for TreeSet we only accept keys.
-    this.#core = new RedBlackTree<K, undefined>([], { comparator, isMapMode: options.isMapMode, enableOrderStatistic: options.enableOrderStatistic });
-
+    this.#core = new RedBlackTree<K, undefined>([], {
+      comparator,
+      isMapMode: options.isMapMode,
+      enableOrderStatistic: options.enableOrderStatistic
+    });
     for (const item of elements) {
-      const k = toElementFn ? toElementFn(item as R) : item as K;
+      const k = toElementFn ? toElementFn(item as R) : (item as K);
       this.add(k);
     }
   }
 
+  /**
+   * Number of elements in the set.
+   */
+  get size(): number {
+    return this.#core.size;
+  }
+
   /**
    * Create the strict default comparator.
    *
@@ -78,11 +91,9 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
         const bb = Object.is(b, -0) ? 0 : b;
         return aa > bb ? 1 : aa < bb ? -1 : 0;
       }
-
       if (typeof a === 'string' && typeof b === 'string') {
         return a > b ? 1 : a < b ? -1 : 0;
       }
-
       if (a instanceof Date && b instanceof Date) {
         const ta = a.getTime();
         const tb = b.getTime();
@@ -90,420 +101,34 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
         if (Number.isNaN(ta) || Number.isNaN(tb)) raise(TypeError, ERR.invalidDate('TreeSet'));
         return ta > tb ? 1 : ta < tb ? -1 : 0;
       }
-
       raise(TypeError, ERR.comparatorRequired('TreeSet'));
     };
   }
 
-  /**
-   * Number of elements in the set.
-   */
-  get size(): number {
-    return this.#core.size;
-  }
-
   /**
    * Whether the set is empty.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Check empty
- *  console.log(new TreeSet().isEmpty()); // true;
+   * @example
+   * // Check empty
+   *  console.log(new TreeSet().isEmpty()); // true;
    */
   isEmpty(): boolean {
     return this.size === 0;
   }
 
-  private _validateKey(key: K): void {
-    if (!this.#isDefaultComparator) return;
-
-    if (typeof key === 'number') {
-      if (Number.isNaN(key)) raise(TypeError, ERR.invalidNaN('TreeSet'));
-      return;
-    }
-
-    if (typeof key === 'string') return;
-
-    if (key instanceof Date) {
-      if (Number.isNaN(key.getTime())) raise(TypeError, ERR.invalidDate('TreeSet'));
-      return;
-    }
-
-    // Other key types should have provided a comparator, so reaching here means misuse.
-    raise(TypeError, ERR.comparatorRequired('TreeSet'));
-  }
-
   /**
    * Add a key to the set (no-op if already present).
    * @remarks Expected time O(log n)
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @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';
+   * @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 {
     this._validateKey(key);
@@ -517,27 +142,11 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    * @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.
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Add multiple keys
- *  const ts = new TreeSet<number>();
- *     ts.addMany([5, 3, 7, 1, 9]);
- *     console.log(ts.size); // 5;
+   * @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[] = [];
@@ -551,201 +160,12 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
   /**
    * Test whether a key exists.
    * @remarks Expected time O(log n)
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @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;
+   * @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);
@@ -756,202 +176,13 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    * Delete a key.
    * @returns `true` if the key existed; otherwise `false`.
    * @remarks Expected time O(log n)
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @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];
+   * @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);
@@ -978,189 +209,11 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
   /**
    * Remove all keys.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove all
- *  const ts = new TreeSet<number>([1, 2]);
- *       ts.clear();
- *       console.log(ts.isEmpty()); // true;
+   * @example
+   * // Remove all
+   *  const ts = new TreeSet<number>([1, 2]);
+   *       ts.clear();
+   *       console.log(ts.isEmpty()); // true;
    */
   clear(): void {
     this.#core.clear();
@@ -1168,188 +221,10 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
   /**
    * Iterate over keys in ascending order.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Get sorted keys
- *  const ts = new TreeSet<number>([30, 10, 20]);
- *       console.log([...ts.keys()]); // [10, 20, 30];
+   * @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();
@@ -1359,188 +234,10 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    * Iterate over values in ascending order.
    *
    * Note: for Set-like containers, `values()` is the same as `keys()`.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Get values (same as keys for Set)
- *  const ts = new TreeSet<number>([2, 1, 3]);
- *       console.log([...ts.values()]); // [1, 2, 3];
+   * @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();
@@ -1550,188 +247,10 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    * Iterate over `[value, value]` pairs (native Set convention).
    *
    * Note: TreeSet stores only keys internally; `[k, k]` is created on-the-fly during iteration.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Iterate entries
- *  const ts = new TreeSet<number>([3, 1, 2]);
- *       console.log([...ts.entries()].map(([k]) => k)); // [1, 2, 3];
+   * @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];
@@ -1745,190 +264,12 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    * Visit each value in ascending order.
    *
    * Callback follows native Set convention: `(value, value2, set)`.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @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];
+   * @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);
@@ -1939,189 +280,11 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    *
    * This mirrors `RedBlackTree.map`: mapping produces a new ordered container.
    * @remarks Time O(n log n) expected, Space O(n)
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Transform
- *  const ts = new TreeSet<number>([1, 2, 3]);
- *       const doubled = ts.map(k => k * 2);
- *       console.log([...doubled]); // [2, 4, 6];
+   * @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>>,
@@ -2131,9 +294,10 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
     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);
+      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;
@@ -2142,197 +306,25 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
   /**
    * Create a new TreeSet containing only values that satisfy the predicate.
    * @remarks Time O(n log n) expected, Space O(n)
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @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];
+   * @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);
+      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;
@@ -2341,189 +333,11 @@ export class TreeSet<K = any, R = K> implements Iterable<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;
+   * @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;
@@ -2535,193 +349,23 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
   /**
    * 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;
+   * @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);
+      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;
@@ -2730,193 +374,23 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
   /**
    * Test whether any value satisfies a predicate.
    * @remarks Time O(n), Space O(1)
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Test any
- *  const ts = new TreeSet<number>([1, 3, 5]);
- *       console.log(ts.some(k => k === 3)); // true;
+   * @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);
+      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;
@@ -2925,194 +399,24 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
   /**
    * 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;
+   * @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);
+      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;
@@ -3121,188 +425,10 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
   /**
    * 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];
+   * @example
+   * // Convert to array
+   *  const ts = new TreeSet<number>([3, 1, 2]);
+   *       console.log(ts.toArray()); // [1, 2, 3];
    */
   toArray(): K[] {
     return [...this];
@@ -3311,315 +437,59 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
   /**
    * Print a human-friendly representation.
    * @remarks Time O(n), Space O(n)
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Display tree
- *  const ts = new TreeSet<number>([1, 2, 3]);
- *       expect(() => ts.print()).not.toThrow();
+   * @example
+   * // Display tree
+   *  const ts = new TreeSet<number>([1, 2, 3]);
+   *       expect(() => ts.print()).not.toThrow();
    */
   print(): void {
     // Delegate to the underlying tree's visualization.
     this.#core.print();
   }
 
-  // Navigable operations
-
   /**
    * Smallest key in the set.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Student grade ranking with custom comparator
- *  interface Student {
- *       name: string;
- *       gpa: number;
- *     }
- *
- *     const ranking = new TreeSet<Student>(
- *       [
- *         { name: 'Alice', gpa: 3.8 },
- *         { name: 'Bob', gpa: 3.5 },
- *         { name: 'Charlie', gpa: 3.9 },
- *         { name: 'Diana', gpa: 3.5 }
- *       ],
- *       { comparator: (a, b) => b.gpa - a.gpa || a.name.localeCompare(b.name) }
- *     );
- *
- *     // Sorted by GPA descending, then name ascending
- *     const names = [...ranking].map(s => s.name);
- *     console.log(names); // ['Charlie', 'Alice', 'Bob', 'Diana'];
- *
- *     // Top student
- *     console.log(ranking.first()?.name); // 'Charlie';
- *
- *     // Filter students with GPA >= 3.8
- *     const honors = ranking.filter(s => s.gpa >= 3.8);
- *     console.log(honors.toArray().map(s => s.name)); // ['Charlie', 'Alice'];
+   * @example
+   * // Student grade ranking with custom comparator
+   *  interface Student {
+   *       name: string;
+   *       gpa: number;
+   *     }
+   *
+   *     const ranking = new TreeSet<Student>(
+   *       [
+   *         { name: 'Alice', gpa: 3.8 },
+   *         { name: 'Bob', gpa: 3.5 },
+   *         { name: 'Charlie', gpa: 3.9 },
+   *         { name: 'Diana', gpa: 3.5 }
+   *       ],
+   *       { comparator: (a, b) => b.gpa - a.gpa || a.name.localeCompare(b.name) }
+   *     );
+   *
+   *     // Sorted by GPA descending, then name ascending
+   *     const names = [...ranking].map(s => s.name);
+   *     console.log(names); // ['Charlie', 'Alice', 'Bob', 'Diana'];
+   *
+   *     // Top student
+   *     console.log(ranking.first()?.name); // 'Charlie';
+   *
+   *     // Filter students with GPA >= 3.8
+   *     const honors = ranking.filter(s => s.gpa >= 3.8);
+   *     console.log(honors.toArray().map(s => s.name)); // ['Charlie', 'Alice'];
    */
   first(): K | undefined {
     return this.#core.getLeftMost();
   }
 
+  // Navigable operations
+
   /**
    * Largest key in the set.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Get the maximum element
- *  const temps = new TreeSet<number>([18, 22, 15, 30, 25]);
- *     console.log(temps.last()); // 30;
- *     console.log(temps.first()); // 15;
+   * @example
+   * // Get the maximum element
+   *  const temps = new TreeSet<number>([18, 22, 15, 30, 25]);
+   *     console.log(temps.last()); // 30;
+   *     console.log(temps.first()); // 15;
    */
   last(): K | undefined {
     return this.#core.getRightMost();
@@ -3627,52 +497,13 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
   /**
    * Remove and return the smallest key.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove and return minimum
- *  const queue = new TreeSet<number>([5, 1, 8, 3]);
- *
- *     console.log(queue.pollFirst()); // 1;
- *     console.log(queue.pollFirst()); // 3;
- *     console.log(queue.size); // 2;
+   * @example
+   * // Remove and return minimum
+   *  const queue = new TreeSet<number>([5, 1, 8, 3]);
+   *
+   *     console.log(queue.pollFirst()); // 1;
+   *     console.log(queue.pollFirst()); // 3;
+   *     console.log(queue.size); // 2;
    */
   pollFirst(): K | undefined {
     const k = this.first();
@@ -3683,51 +514,12 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
   /**
    * Remove and return the largest key.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove and return maximum
- *  const stack = new TreeSet<number>([10, 20, 30]);
- *
- *     console.log(stack.pollLast()); // 30;
- *     console.log(stack.size); // 2;
+   * @example
+   * // Remove and return maximum
+   *  const stack = new TreeSet<number>([10, 20, 30]);
+   *
+   *     console.log(stack.pollLast()); // 30;
+   *     console.log(stack.size); // 2;
    */
   pollLast(): K | undefined {
     const k = this.last();
@@ -3738,172 +530,22 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
   /**
    * Smallest key that is >= the given key.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Finding nearest available time slot
- *  // Available appointment times (minutes from midnight)
- *     const slots = new TreeSet<number>([540, 600, 660, 720, 840, 900]);
- *
- *     // Customer wants something around 10:30 (630 min)
- *     const nearest = slots.ceiling(630);
- *     console.log(nearest); // 660; // 11:00 AM
- *
- *     // What's the latest slot before 2:00 PM (840)?
- *     const before2pm = slots.lower(840);
- *     console.log(before2pm); // 720; // 12:00 PM
- *
- *     // Book the 11:00 slot
- *     slots.delete(660);
- *     console.log(slots.ceiling(630)); // 720;
+   * @example
+   * // Finding nearest available time slot
+   *  // Available appointment times (minutes from midnight)
+   *     const slots = new TreeSet<number>([540, 600, 660, 720, 840, 900]);
+   *
+   *     // Customer wants something around 10:30 (630 min)
+   *     const nearest = slots.ceiling(630);
+   *     console.log(nearest); // 660; // 11:00 AM
+   *
+   *     // What's the latest slot before 2:00 PM (840)?
+   *     const before2pm = slots.lower(840);
+   *     console.log(before2pm); // 720; // 12:00 PM
+   *
+   *     // Book the 11:00 slot
+   *     slots.delete(660);
+   *     console.log(slots.ceiling(630)); // 720;
    */
   ceiling(key: K): K | undefined {
     this._validateKey(key);
@@ -3912,164 +554,14 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
   /**
    * Largest key that is <= the given key.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Largest element ≤ target
- *  const breakpoints = new TreeSet<number>([320, 768, 1024, 1280, 1920]);
- *
- *     // Current width is 800 → which breakpoint applies?
- *     console.log(breakpoints.floor(800)); // 768;
- *     console.log(breakpoints.floor(1024)); // 1024; // exact match
- *     console.log(breakpoints.floor(100)); // undefined;
+   * @example
+   * // Largest element ≤ target
+   *  const breakpoints = new TreeSet<number>([320, 768, 1024, 1280, 1920]);
+   *
+   *     // Current width is 800 → which breakpoint applies?
+   *     console.log(breakpoints.floor(800)); // 768;
+   *     console.log(breakpoints.floor(1024)); // 1024; // exact match
+   *     console.log(breakpoints.floor(100)); // undefined;
    */
   floor(key: K): K | undefined {
     this._validateKey(key);
@@ -4078,162 +570,12 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
   /**
    * Smallest key that is > the given key.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Smallest element strictly > target
- *  const levels = new TreeSet<number>([1, 5, 10, 25, 50, 100]);
- *
- *     console.log(levels.higher(10)); // 25;
- *     console.log(levels.higher(100)); // undefined;
+   * @example
+   * // Smallest element strictly > target
+   *  const levels = new TreeSet<number>([1, 5, 10, 25, 50, 100]);
+   *
+   *     console.log(levels.higher(10)); // 25;
+   *     console.log(levels.higher(100)); // undefined;
    */
   higher(key: K): K | undefined {
     this._validateKey(key);
@@ -4242,162 +584,12 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
   /**
    * Largest key that is < the given key.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Largest element strictly < target
- *  const tiers = new TreeSet<number>([100, 200, 500, 1000]);
- *
- *     console.log(tiers.lower(500)); // 200;
- *     console.log(tiers.lower(100)); // undefined;
+   * @example
+   * // Largest element strictly < target
+   *  const tiers = new TreeSet<number>([100, 200, 500, 1000]);
+   *
+   *     console.log(tiers.lower(500)); // 200;
+   *     console.log(tiers.lower(100)); // undefined;
    */
   lower(key: K): K | undefined {
     this._validateKey(key);
@@ -4409,227 +601,71 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
    *
    * @param range `[low, high]`
    * @param options Inclusive/exclusive bounds (defaults to inclusive).
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // IP address blocklist with range checking
- *  // Simplified: use numeric IP representation
- *     const blocklist = new TreeSet<number>([
- *       167772160, // 10.0.0.0
- *       167772416, // 10.0.1.0
- *       167772672, // 10.0.2.0
- *       167773184  // 10.0.4.0
- *     ]);
- *
- *     // Check if any blocked IP is in range 10.0.1.0 - 10.0.3.0
- *     const inRange = blocklist.rangeSearch([167772416, 167772928]);
- *     console.log(inRange); // [167772416, 167772672];
- *
- *     // Quick membership check
- *     console.log(blocklist.has(167772416)); // true;
- *     console.log(blocklist.has(167772800)); // false;
+   * @example
+   * // IP address blocklist with range checking
+   *  // Simplified: use numeric IP representation
+   *     const blocklist = new TreeSet<number>([
+   *       167772160, // 10.0.0.0
+   *       167772416, // 10.0.1.0
+   *       167772672, // 10.0.2.0
+   *       167773184 // 10.0.4.0
+   *     ]);
+   *
+   *     // Check if any blocked IP is in range 10.0.1.0 - 10.0.3.0
+   *     const inRange = blocklist.rangeSearch([167772416, 167772928]);
+   *     console.log(inRange); // [167772416, 167772672];
+   *
+   *     // Quick membership check
+   *     console.log(blocklist.has(167772416)); // true;
+   *     console.log(blocklist.has(167772800)); // false;
    */
   rangeSearch(range: [K, K], options: TreeSetRangeOptions = {}): K[] {
     const { lowInclusive = true, highInclusive = true } = options;
-
     const [low, high] = range;
     this._validateKey(low);
     this._validateKey(high);
-
     const keys = this.#core.rangeSearch([low, high]) as (K | undefined)[];
     const out: K[] = [];
     const cmp = this.#core.comparator;
-
     for (const k of keys) {
-      /* istanbul ignore next -- defensive: tree keys are never undefined */ if (k === undefined) continue;
+      /* istanbul ignore next -- defensive: tree keys are never undefined */
+      if (k === undefined) continue;
       if (!lowInclusive && cmp(k, low) === 0) continue;
       if (!highInclusive && cmp(k, high) === 0) continue;
       out.push(k);
     }
-
     return out;
   }
 
-  // ─── Order-Statistic Methods ───────────────────────────
-
   /**
    * Returns the element at the k-th position in tree order (0-indexed).
    * @remarks Time O(log n). Requires `enableOrderStatistic: true`.
-   
-   
-   
-    * @example
- * // Find k-th element in a TreeSet
- *  const set = new TreeSet<number>([30, 10, 50, 20, 40], { enableOrderStatistic: true });
- *       console.log(set.getByRank(0)); // 10;
- *       console.log(set.getByRank(2)); // 30;
- *       console.log(set.getRank(30)); // 2;
+   * @example
+   * // Find k-th element in a TreeSet
+   *  const set = new TreeSet<number>([30, 10, 50, 20, 40], { enableOrderStatistic: true });
+   *       console.log(set.getByRank(0)); // 10;
+   *       console.log(set.getByRank(2)); // 30;
+   *       console.log(set.getRank(30)); // 2;
    */
   getByRank(k: number): K | undefined {
     return this.#core.getByRank(k);
   }
 
+  // ─── Order-Statistic Methods ───────────────────────────
+
   /**
    * Returns the 0-based rank of a key (number of elements that precede it in tree order).
    * @remarks Time O(log n). Requires `enableOrderStatistic: true`.
-    * @example
- * // Get the rank of a key in sorted order
- *  const tree = new TreeSet<number>(
- *         [10, 20, 30, 40, 50],
- *         { enableOrderStatistic: true }
- *       );
- *       console.log(tree.getRank(10)); // 0;  // smallest → rank 0
- *       console.log(tree.getRank(30)); // 2;  // 2 elements before 30 in tree order
- *       console.log(tree.getRank(50)); // 4;  // largest → rank 4
- *       console.log(tree.getRank(25)); // 2;
+   * @example
+   * // Get the rank of a key in sorted order
+   *  const tree = new TreeSet<number>(
+   *         [10, 20, 30, 40, 50],
+   *         { enableOrderStatistic: true }
+   *       );
+   *       console.log(tree.getRank(10)); // 0;  // smallest → rank 0
+   *       console.log(tree.getRank(30)); // 2;  // 2 elements before 30 in tree order
+   *       console.log(tree.getRank(50)); // 4;  // largest → rank 4
+   *       console.log(tree.getRank(25)); // 2;
    */
   getRank(key: K): number {
     return this.#core.getRank(key);
@@ -4638,222 +674,165 @@ 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 by position in tree order
- *  const tree = new TreeSet<number>(
- *         [10, 20, 30, 40, 50, 60, 70, 80, 90],
- *         { enableOrderStatistic: true }
- *       );
- *       const pageSize = 3;
- *
- *       // Page 1
- *       console.log(tree.rangeByRank(0, pageSize - 1)); // [10, 20, 30];
- *       // Page 2
- *       console.log(tree.rangeByRank(pageSize, 2 * pageSize - 1)); // [40, 50, 60];
- *       // Page 3
- *       console.log(tree.rangeByRank(2 * pageSize, 3 * pageSize - 1)); // [70, 80, 90];
+   * @example
+   * // Pagination by position in tree order
+   *  const tree = new TreeSet<number>([10, 20, 30, 40, 50, 60, 70, 80, 90], { enableOrderStatistic: true });
+   *       const pageSize = 3;
+   *
+   *       // Page 1
+   *       console.log(tree.rangeByRank(0, pageSize - 1)); // [10, 20, 30];
+   *       // Page 2
+   *       console.log(tree.rangeByRank(pageSize, 2 * pageSize - 1)); // [40, 50, 60];
+   *       // Page 3
+   *       console.log(tree.rangeByRank(2 * pageSize, 3 * pageSize - 1)); // [70, 80, 90];
    */
   rangeByRank(start: number, end: number): K[] {
     return this.#core.rangeByRank(start, end).filter((k): k is K => k !== undefined);
   }
 
+  /**
+   * 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;
+  }
+
   /**
    * Creates a shallow clone of this set.
    * @remarks Time O(n log n), Space O(n)
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Deep clone
- *  const ts = new TreeSet<number>([1, 2, 3]);
- *       const copy = ts.clone();
- *       copy.delete(1);
- *       console.log(ts.has(1)); // true;
+   * @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 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]);
+   *       const copy = ts.clone();
+   *       copy.delete(1);
+   *       console.log(ts.has(1)); // true;
    */
   clone(): TreeSet<K> {
     return new TreeSet<K>(this, {
@@ -4861,4 +840,19 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
       isMapMode: this.#core.isMapMode
     });
   }
+
+  private _validateKey(key: K): void {
+    if (!this.#isDefaultComparator) return;
+    if (typeof key === 'number') {
+      if (Number.isNaN(key)) raise(TypeError, ERR.invalidNaN('TreeSet'));
+      return;
+    }
+    if (typeof key === 'string') return;
+    if (key instanceof Date) {
+      if (Number.isNaN(key.getTime())) raise(TypeError, ERR.invalidDate('TreeSet'));
+      return;
+    }
+    // Other key types should have provided a comparator, so reaching here means misuse.
+    raise(TypeError, ERR.comparatorRequired('TreeSet'));
+  }
 }